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