public static Key LoadNBEcKey(String base58)
{
byte[] b = Multibase.Decode(base58, out MultibaseEncoding encoding);
EcKey key = EcKey.FromAsn1(b);
return(new Key(key.GetPrivKeyBytes()));
}
public static void SaveEcKey(Key nbEcKey, IResourceDataAccess resourceDataAccess)
{
byte[] bytes = EcKey.ToAsn1(nbEcKey.ToBytes(), nbEcKey.PubKey.ToBytes());
string base58 = Multibase.Encode(MultibaseEncoding.Base58Btc, bytes);
resourceDataAccess.Save(base58);
}
private ulong StringToInt(string value)
{
byte[] codedBytes = Multibase.Decode("Z" + value, out MultibaseEncoding _);
ulong codedValue = BitConverter.ToUInt64(codedBytes, 0);
return(Rearrange(codedValue));
}
public override void Decode(string value)
{
var addr = value.Split(':');
if (addr.Length != 2)
{
throw new Exception("Failed to parse addr");
}
if (addr[0].Length != 16)
{
throw new Exception("Failed to parse addr");
}
if (!Multibase.TryDecode(addr[0], out var encoding, out _) || encoding != MultibaseEncoding.Base32Lower)
{
throw new InvalidOperationException($"{value} is not a valid onion address.");
}
var i = ushort.Parse(addr[1]);
if (i < 1)
{
throw new Exception("Failed to parse addr");
}
Value = value;
}
public static void RunBatchDeleteTest(IBatchingDatastore <byte[]> ds)
{
var keys = new List <DatastoreKey>();
for (var i = 0; i < 20; i++)
{
var blk = new byte[16];
TestContext.CurrentContext.Random.NextBytes(blk);
var key = new DatastoreKey(Multibase.EncodeRaw(Multibase.Base32, blk.Take(8).ToArray()));
keys.Add(key);
ds.Put(key, blk);
}
var batch = ds.Batch();
foreach (var key in keys)
{
batch.Delete(key);
}
batch.Commit();
foreach (var key in keys)
{
Assert.Throws <KeyNotFoundException>(() => ds.Get(key));
}
}
private string IntToString(ulong value)
{
var codedValue = Rearrange(value);
byte[] codedBytes = BitConverter.GetBytes(codedValue);
return(Multibase.Encode(MultibaseEncoding.Base58Flickr, codedBytes).Substring(1));
}
public static void RunBatchTest(IBatchingDatastore <byte[]> ds)
{
var batch = ds.Batch();
var blocks = new List <byte[]>();
var keys = new List <DatastoreKey>();
for (var i = 0; i < 20; i++)
{
var blk = new byte[256 * 1024];
TestContext.CurrentContext.Random.NextBytes(blk);
blocks.Add(blk);
var key = new DatastoreKey(Multibase.EncodeRaw(Multibase.Base32, blk.Take(8).ToArray()));
keys.Add(key);
batch.Put(key, blk);
}
foreach (var key in keys)
{
Assert.Throws <KeyNotFoundException>(() => ds.Get(key));
}
batch.Commit();
for (var i = 0; i < keys.Count; i++)
{
var blk = ds.Get(keys[i]);
Assert.That(blk, Is.EqualTo(blocks[i]));
}
}
public override byte[] ToBytes()
{
var s = (string)Value;
var addr = s.Split(':');
if (addr.Length != 2)
{
throw new Exception("Failed to parse addr");
}
if (addr[0].Length != 16)
{
throw new Exception("Failed to parse addr");
}
if (!Multibase.TryDecode(addr[0], out var encoding, out var onionHostBytes) || encoding != MultibaseEncoding.Base32Lower)
{
throw new InvalidOperationException($"{s} is not a valid onion address.");
}
var i = ushort.Parse(addr[1]);
if (i < 1)
{
throw new Exception("Failed to parse addr");
}
return(onionHostBytes.Concat(Binary.BigEndian.GetBytes(i)).ToArray());
}
public void Decode_GivenInvalidChars_ThrowsInvalidOperationException()
{
// prefix 0 - base2
// value 99 - invalid chars
Assert.Throws <InvalidOperationException>(() => Multibase.Decode("099", out string _));
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
var token = JToken.Load(reader);
switch (token.Type)
{
case JTokenType.Null:
return(null);
case JTokenType.String:
return(new PeerId(Multibase.DecodeRaw(Multibase.Base58, (string)token)));
case JTokenType.Bytes:
return(new PeerId((byte[])token));
case JTokenType.Object:
var value = (string)token["$value"];
return(value == null ? null : new PeerId(Multibase.DecodeRaw(Multibase.Base58, value)));
default:
throw new SerializationException("Unknown PeerId format");
}
}
async void videoSelection()
{
if (!CrossMedia.Current.IsPickVideoSupported)
{
await DisplayAlert("Photos Not Supported", ":( Permission not granted to photos.", "OK");
return;
}
try
{
Stream stream = null;
var file = await CrossMedia.Current.PickVideoAsync().ConfigureAwait(true);
if (file == null)
{
return;
}
stream = file.GetStream();
//file.Dispose();
// imgIcon.Source = ImageSource.FromStream(() => stream);
//Hash with Multihash
Multibase multibase = Multibase.Base58;
bytes = null;
mh = null;
bytes = GetImageStreamAsBytes(stream);
var multihash = Multihash.Sum <SHA2_256>(bytes);
string checkData = multibase.Encode(multihash);
stringHash.Text = checkData;
//Hash With IPFS
CancellationToken token = new CancellationToken(false);
IpfsClient ipfs = new IpfsClient("http://10.0.3.2:5001");
IFileSystemNode fileSystemNode = await ipfs.FileSystem.AddFileAsync(file.Path, null, token);
Debug.WriteLine("fileSystemNode Hash:" + fileSystemNode.Id);
imageHash.Text = fileSystemNode.Id;
}
catch (Exception err)
{
Debug.WriteLine("Message:" + err.Message);
Debug.WriteLine("Source:" + err.Source);
Debug.WriteLine("Stack Trace:" + err.StackTrace);
}
}
public void TestTryDecoding_GivenValidEncodedInput_Unprefixed(string input, MultibaseEncoding encoding)
{
var expected = "Decentralize everything!!";
var result = Multibase.TryDecode(input, out var decodedEncoding, out var decodedBytes);
Assert.True(result);
Assert.Equal(encoding, decodedEncoding);
Assert.Equal(expected, Encoding.UTF8.GetString(decodedBytes));
}
public void TestVector_6(string encoding, string encoded)
{
var expected = "hello world";
var decoded = Multibase.Decode(encoded, out string mbEncoding, false);
Assert.Equal(encoding, mbEncoding);
Assert.Equal(expected, Encoding.UTF8.GetString(decoded));
}
// Official test vectors
private static void TestVector(string encoding, string encoded, string expected)
{
var decoded = Multibase.Decode(encoded, out string mbEncoding);
Assert.Equal(encoding, mbEncoding);
Assert.Equal(expected, Encoding.UTF8.GetString(decoded));
var rencoded = Multibase.Encode(mbEncoding, decoded);
Assert.Equal(encoded, rencoded);
}
public async Task TestBase58ConcurrentDecoding()
{
var tasks = Enumerable.Range(1, 10).Select(_ => Task.Run(() =>
{
var success = Multibase.TryDecode("Z6BLZQNPgws5ahFtr8x", out var encoding, out var bytes);
Assert.True(success);
Assert.Equal(MultibaseEncoding.Base58Flickr, encoding);
Assert.Equal("Concurrency !", Encoding.UTF8.GetString(bytes, 0, bytes.Length));
}));
await Task.WhenAll(tasks);
}
public void TestRoundTrip(MultibaseEncoding encoding)
{
var rand = new Random(Environment.TickCount);
var buf = new byte[rand.Next(16, 256)];
rand.NextBytes(buf);
var encoded = Multibase.EncodeRaw(encoding, buf);
var decoded = Multibase.DecodeRaw(encoding, encoded);
Assert.Equal(decoded, buf);
}
public string Sign(string input)
{
var privateKeyParameters = new ECPrivateKeyParameters(_priv, _ecParams);
ISigner signer = SignerUtilities.GetSigner("SHA-256withECDSA");
signer.Init(true, privateKeyParameters);
var bytes = Encoding.UTF8.GetBytes(input);
signer.BlockUpdate(bytes, 0, bytes.Length);
var signature = signer.GenerateSignature();
return(Multibase.Encode(MultibaseEncoding.Base58Btc, signature));
}
public static bool TryParse(string s, MultibaseEncoding encoding, out Multihash mh)
{
try
{
var bytes = Multibase.DecodeRaw(encoding, s);
mh = Decode(bytes);
return(true);
}
catch (Exception) { }
mh = null;
return(false);
}
public override string ToString()
{
switch (_version)
{
case 0:
return(Hash.ToString(Multibase.Base58));
case 1:
return(Multibase.Encode(Multibase.Base58, ToBytes()));
default:
throw new Exception("unsupported version");
}
}
public static Cid Decode(string v)
{
if (v.Length < 2)
{
throw new ArgumentException("cid too short", nameof(v));
}
if (v.Length == 46 && v.Substring(0, 2) == "Qm")
{
return(new Cid(Multihash.Parse(v)));
}
return(Cast(Multibase.Decode(v)));
}
async void local()
{
try
{
string imagePath = "NethereumWithTraditionalMVVM.Images.download.jpeg";
Assembly assembly = typeof(MainPage).GetTypeInfo().Assembly;
string result;
using (Stream stream = assembly.GetManifestResourceStream(imagePath))
{
long length = stream.Length;
byte[] buffer = new byte[length];
stream.Read(buffer, 0, (int)length);
bytes = GetImageStreamAsBytes(stream);
CancellationToken token = new CancellationToken(false);
IpfsClient ipfs = new IpfsClient("http://10.0.3.2:5001");
IFileSystemNode fileSystemNode = await ipfs.FileSystem.AddFileAsync(imagePath, null, token);
Debug.WriteLine("fileSystemNode Hash:" + fileSystemNode.Id);
bytes = null;
bytes = GetImageStreamAsBytes(fileSystemNode.DataStream);
mh = Multihash.Sum <SHA2_256>(bytes);
stringHash.Text = fileSystemNode.Id;
Debug.WriteLine("bytes after multihash:" + mh);
Multibase multibase = Multibase.Base58;
string checkData = multibase.Encode(mh);
Debug.WriteLine("Multihash after Base58 Encode:" + checkData);
imageHash.Text = checkData;
}
}
catch (Exception err)
{
Debug.WriteLine("Message:" + err.Message);
Debug.WriteLine("Source:" + err.Source);
Debug.WriteLine("Stack Trace:" + err.StackTrace);
}
}
public static ApiSig CreateApiSig(string secret, DateTime?date = null)
{
if (date is null)
{
date = DateTime.UtcNow.AddMinutes(30);
}
byte[] sec = Multibase.Decode(secret, out string _);
string msg = date.Value.ToString("o", CultureInfo.InvariantCulture);
using HMACSHA256 hash = new (sec);
byte[] mac = hash.ComputeHash(Encoding.ASCII.GetBytes(msg));
string sig = Multibase.Encode(MultibaseEncoding.Base32Lower, mac);
return(new ApiSig()
{
Msg = msg,
Sig = sig
});
}
public byte[] RawData()
{
using (var stream = new MemoryStream())
{
stream.Write($"tag {dataSize}\x00");
stream.Write($"object {Multibase.EncodeRaw(Multibase.Base16, Object.ToSha())}\n");
stream.Write($"type {Type}\n");
stream.Write($"tag {Name}\n");
if (Tagger != null)
{
stream.Write($"tagger {Tagger}\n");
}
if (!string.IsNullOrEmpty(Message))
{
stream.Write($"\n{Message}");
}
return(stream.ToArray());
}
}
async void Handle_Clicked(object sender, System.EventArgs e)
{
try
{
string textValue = txtValue.Text;
//Hash with Mutlihash
Encoding encoding = Encoding.UTF8;
bytes = encoding.GetBytes(textValue);
mh = Multihash.Sum <SHA2_256>(bytes);
Debug.WriteLine("string bytes after Multihash:" + mh);
Multibase multibase = Multibase.Base58;
string checkData = multibase.Encode(mh);
stringHash.Text = checkData;
//Hash with IPFS
CancellationToken token = new CancellationToken(false);
IpfsClient ipfs = new IpfsClient("http://10.0.3.2:5001");
IFileSystemNode fileSystemNode = await ipfs.FileSystem.AddTextAsync(textValue, null, token);
Debug.WriteLine("fileSystemNode Hash:" + fileSystemNode.Id);
imageHash.Text = fileSystemNode.Id;
}
catch (Exception err)
{
Debug.WriteLine("Message:" + err.Message);
Debug.WriteLine("Source:" + err.Source);
Debug.WriteLine("Stack Trace:" + err.StackTrace);
}
}
private static void Process(Options options)
{
using (options.Source)
{
byte[] data = null;
using (var mem = new MemoryStream())
{
options.Source.CopyTo(mem);
data = mem.ToArray();
}
var mh = Multihash.Sum(options.Algorithm, data, options.Length);
if (string.IsNullOrEmpty(options.Checksum))
{
Console.WriteLine(mh.ToString(options.Encoding));
Environment.Exit(0);
}
var checksum = Multibase.DecodeRaw(options.Encoding, options.Checksum);
if (!checksum.SequenceEqual(mh.Digest))
{
if (!options.Quiet)
{
Console.WriteLine($"Digest mismatch, got: {Multibase.EncodeRaw(options.Encoding, mh.Digest)}, wanted: {Multibase.EncodeRaw(options.Encoding, checksum)}");
}
Environment.Exit(1);
}
if (!options.Quiet)
{
Console.WriteLine("Checksum match");
}
}
}
public static PublicKey FromString(string str)
{
byte[] decoded = Multibase.Decode(str, out string _);
return(new PublicKey(LibP2P.Crypto.PublicKey.Unmarshal(decoded)));
}
public override string ToString()
{
return(Multibase.Encode(MultibaseEncoding.Base32Lower, this.Bytes));
}
async void pickPhoto(object sender, System.EventArgs e)
{
if (!CrossMedia.Current.IsPickPhotoSupported)
{
await DisplayAlert("Photos Not Supported", ":( Permission not granted to photos.", "OK");
return;
}
try
{
Stream stream = null;
var file = await CrossMedia.Current.PickPhotoAsync().ConfigureAwait(true);
if (file == null)
{
return;
}
stream = file.GetStream();
// imgIcon.Source = ImageSource.FromStream(() => stream);
//Hash With Multihash
Multibase multibase = Multibase.Base58;
bytes = null;
mh = null;
bytes = GetImageStreamAsBytes(stream);
string hexString = bytes.ToBase64Url();
if (App.HexString == null)
{
App.HexString = hexString;
}
else
{
if (App.HexString == hexString)
{
Debug.WriteLine("both hex are equal");
}
else
{
Debug.WriteLine("Both strings are not equal");
}
}
Debug.WriteLine(bytes.ToHexString());
var multihash = Multihash.Sum <SHA2_256>(bytes);
string checkData = multibase.Encode(multihash);
stringHash.Text = checkData;
//Hash with IPFS
CancellationToken token = new CancellationToken(false);
IpfsClient ipfs = new IpfsClient("http://10.0.3.2:5001");
IFileSystemNode fileSystemNode = await ipfs.FileSystem.AddFileAsync(file.Path);
Debug.WriteLine("fileSystemNode Hash:" + fileSystemNode.Id);
imageHash.Text = fileSystemNode.Id;
file.Dispose();
}
catch (Exception err)
{
Debug.WriteLine("Message:" + err.Message);
Debug.WriteLine("Source:" + err.Source);
Debug.WriteLine("Stack Trace:" + err.StackTrace);
}
}
public string ToString(MultibaseEncoding encoding) => Multibase.EncodeRaw(encoding, _bytes.Value);
public void Encode_GivenUnknownEncoding_ThrowsUnsupportedException()
{
Assert.Throws <NotSupportedException>(() => Multibase.Encode((MultibaseEncoding)0x2000, new byte[] { 0, 1, 2, 3 }));
}
