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();
}
