public void Export_BadBase() { var psk = new PreSharedKey().Generate(); var s = new StringWriter(); psk.Export(s, "bad"); }
public void Generate() { var psk = new PreSharedKey().Generate(); Assert.IsNotNull(psk.Value); Assert.AreEqual(256, psk.Length); }
public void Defaults() { var psk = new PreSharedKey(); Assert.IsNull(psk.Value); Assert.AreEqual(0, psk.Length); }
public void ReadingInvalidNonce() { var psk = new PreSharedKey().Generate(); var secure = new Psk1Stream(Stream.Null, psk); secure.ReadByte(); }
public async Task PrivateNetwork_WithSwarmKeyFile() { using (var ipfs = CreateNode()) { try { var key = new PreSharedKey().Generate(); var path = Path.Combine(ipfs.Options.Repository.ExistingFolder(), "swarm.key"); using (var x = File.CreateText(path)) { key.Export(x); } var swarm = await ipfs.SwarmService; Assert.IsNotNull(swarm.NetworkProtector); } finally { if (Directory.Exists(ipfs.Options.Repository.Folder)) { Directory.Delete(ipfs.Options.Repository.Folder, true); } } } }
public void LengthInBits() { var psk = new PreSharedKey { Value = new byte[] { 1, 2 } }; Assert.AreEqual(16, psk.Length); }
public void Fingerprint() { var key = new PreSharedKey { Value = "e8d6d31e8e02000010d7d31e8e020000f0d1fc609300000078f0d31e8e020000".ToHexBuffer() }; var expected = "56a19299c05df1f2bb0e1d466002b6d9"; Assert.AreEqual(expected, key.Fingerprint().ToHexString()); }
public void Export_Base16_is_default() { var psk = new PreSharedKey().Generate(); var s1 = new StringWriter(); var s2 = new StringWriter(); psk.Export(s1); psk.Export(s2); Assert.AreEqual(s1.ToString(), s2.ToString()); }
/// <summary> /// Creates a new instance of the <see cref="Psk1Stream"/> class. /// </summary> /// <param name="stream"> /// The source/destination of the unprotected stream. /// </param> /// <param name="key"> /// The pre-shared 256-bit key for the private network of peers. /// </param> public Psk1Stream(Stream stream, PreSharedKey key) { if (key.Length != KeyBitLength) { throw new Exception($"The pre-shared key must be {KeyBitLength} bits in length."); } this._stream = stream; this._key = key; }
/// <summary> /// Add a PSK /// </summary> /// <param name="key">A PreSharedKey</param> /// <returns>PreSharedKey</returns> public PreSharedKey AddPsk(PreSharedKey key) { try { return(Task.Run(async() => await AddPskAsync(key)).Result); } catch (CloudApiException) { throw; } }
public async Task Read_From_OtherNode() { using (var a = TestDfs.GetTestDfs()) { using (var b = TestDfs.GetTestDfs()) { using (var c = TestDfs.GetTestDfs()) { var psk = new PreSharedKey().Generate(); // Start bootstrap node. b.Options.Discovery.DisableMdns = true; b.Options.Swarm.MinConnections = 0; b.Options.Swarm.PrivateNetworkKey = psk; b.Options.Discovery.BootstrapPeers = new MultiAddress[0]; await b.StartAsync(); var bootstrapPeers = new[] { b.LocalPeer.Addresses.First() }; TestContext.WriteLine($"B is {b.LocalPeer}"); // Node that has the content. c.Options.Discovery.DisableMdns = true; c.Options.Swarm.MinConnections = 0; c.Options.Swarm.PrivateNetworkKey = psk; c.Options.Discovery.BootstrapPeers = bootstrapPeers; await c.StartAsync(); await c.SwarmApi.ConnectAsync(bootstrapPeers[0]); TestContext.WriteLine($"C is {c.LocalPeer}"); var fsn = await c.UnixFsApi.AddTextAsync("some content"); var cid = fsn.Id; // Node that reads the content. a.Options.Discovery.DisableMdns = true; a.Options.Swarm.MinConnections = 0; a.Options.Swarm.PrivateNetworkKey = psk; a.Options.Discovery.BootstrapPeers = bootstrapPeers; await a.StartAsync(); TestContext.WriteLine($"A is {a.LocalPeer}"); var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30)); var content = await a.UnixFsApi.ReadAllTextAsync(cid, cts.Token); Assert.AreEqual("some content", content); } } } }
public void Export_Base64() { var psk1 = new PreSharedKey().Generate(); var s = new StringWriter(); psk1.Export(s, "base64"); var psk2 = new PreSharedKey(); psk2.Import(new StringReader(s.ToString())); CollectionAssert.AreEqual(psk1.Value, psk2.Value); }
public async Task Protect() { var psk = new PreSharedKey().Generate(); var protector = new Psk1Protector { Key = psk }; var connection = new PeerConnection { Stream = Stream.Null }; var protectedStream = await protector.ProtectAsync(connection); Assert.IsInstanceOfType(protectedStream, typeof(Psk1Stream)); }
/// <summary> /// Add a PSK /// </summary> /// <param name="key">A PreSharedKey</param> /// <returns>A Task</returns> public async Task <PreSharedKey> AddPskAsync(PreSharedKey key) { try { await api.UploadPreSharedKeyAsync(PreSharedKey.CreateRequest(key)); return(key); } catch (connector_bootstrap.Client.ApiException e) { throw new CloudApiException(e.ErrorCode, e.Message, e.ErrorContent); } }
/// <summary> /// Get a PreSharedKey /// </summary> /// <param name="endpointName">The ID of PreSharedKey</param> /// <returns>A PreSharedKey without the SecretKey</returns> public async Task <PreSharedKey> GetPskAsync(string endpointName) { try { var psk = await api.GetPreSharedKeyAsync(endpointName); return(PreSharedKey.Map(psk)); } catch (connector_bootstrap.Client.ApiException e) { return(HandleNotFound <PreSharedKey, connector_bootstrap.Client.ApiException>(e)); } }
public void Import_JS_Generated() { var key = "/key/swarm/psk/1.0.0/\n" + "/base16/\n" + "e8d6d31e8e02000010d7d31e8e020000f0d1fc609300000078f0d31e8e020000"; var psk2 = new PreSharedKey(); psk2.Import(new StringReader(key)); var expected = "e8d6d31e8e02000010d7d31e8e020000f0d1fc609300000078f0d31e8e020000".ToHexBuffer(); CollectionAssert.AreEqual(expected, psk2.Value); }
public void FirstWriteSendsNonce() { var psk = new PreSharedKey().Generate(); var insecure = new MemoryStream(); var secure = new Psk1Stream(insecure, psk); secure.WriteByte(0x10); Assert.AreEqual(24 + 1, insecure.Length); insecure = new MemoryStream(); secure = new Psk1Stream(insecure, psk); secure.Write(new byte[10], 0, 10); Assert.AreEqual(24 + 10, insecure.Length); insecure = new MemoryStream(); secure = new Psk1Stream(insecure, psk); secure.WriteAsync(new byte[12], 0, 12).Wait(); Assert.AreEqual(24 + 12, insecure.Length); }
public void Roundtrip() { var psk = new PreSharedKey().Generate(); var plain = new byte[] { 1, 2, 3 }; var plain1 = new byte[3]; var plain2 = new byte[3]; var insecure = new MemoryStream(); var secure = new Psk1Stream(insecure, psk); secure.Write(plain, 0, plain.Length); secure.Flush(); insecure.Position = 0; secure = new Psk1Stream(insecure, psk); secure.Read(plain1, 0, plain1.Length); CollectionAssert.AreEqual(plain, plain1); insecure.Position = 0; secure = new Psk1Stream(insecure, psk); secure.ReadAsync(plain2, 0, plain2.Length).Wait(); CollectionAssert.AreEqual(plain, plain2); }
public void BadKeyLength() { var psk = new PreSharedKey(); var _ = new Psk1Stream(Stream.Null, psk); }
public static void PreSharedKeyIdSetter(PreSharedKey self, string value) { self.endpointName = value; self.Id = value; }
public static string PreSharedKeyIdGetter(PreSharedKey self) { return(self.endpointName ?? self.Id); }
public void SetUp() { PreSharedKeyGenerator = new PreSharedKey(); }