/// <summary>
/// Try to decode an encoded string. If prefixed with a multibase prefix it's guaranteed to give the correct value, if not there's no guarantee it will pick the right encoding.
/// </summary>
/// <param name="input">Encoded string</param>
/// <param name="encoding">Guessed encoding</param>
/// <param name="bytes">Decoded bytes</param>
/// <returns>True on success (no guarantee it's correct), false on error</returns>
public static bool TryDecode(string input, out MultibaseEncoding encoding, out byte[] bytes)
{
try
{
// special case for base2 without prefix
if (input[0] == '0' && input.Length % 8 == 0)
{
throw new Exception();
}
bytes = Decode(input, out encoding);
return(true);
}
catch
{
foreach (var @base in _bases.Values.Skip(1).Where(b => b.IsValid(input)))
{
try
{
bytes = @base.Decode(input);
encoding = _bases.SingleOrDefault(kv => kv.Value.Equals(@base)).Key;
return(true);
}
catch
{
}
}
}
encoding = default(MultibaseEncoding);
bytes = null;
return(false);
}
/// <summary>
/// Decode an multibase encoded string.
/// </summary>
/// <param name="input">Encoded string</param>
/// <param name="encoding">Encoding used</param>
/// <param name="strict">Don't allow non-valid characters for given encoding</param>
/// <returns>Bytes</returns>
public static byte[] Decode(string input, out MultibaseEncoding encoding, bool strict = true)
{
if (string.IsNullOrEmpty(input))
{
throw new ArgumentNullException(nameof(input));
}
var @base = _bases.Values.SingleOrDefault(b => b.Prefix == input[0]);
if (@base == null)
{
throw new NotSupportedException($"{input[0]} is an unknown encoding prefix.");
}
var value = input.Substring(1);
encoding = _bases.SingleOrDefault(kv => kv.Value.Equals(@base)).Key;
if (strict && [email protected](value))
{
throw new InvalidOperationException($"{value} contains invalid chars for {encoding}.");
}
return(@base.Decode(value));
}
/// <summary>
/// Set possibly file extension properties from a FileInfo object:
/// - size
/// - checksum
/// </summary>
/// <returns></returns>
public static async Task SetFileExtensionProperties(this FileStacExtension fileStacExtension,
Stream stream,
HashType hashType = HashType.SHA1,
MultibaseEncoding encoding = MultibaseEncoding.Base16Lower)
{
await fileStacExtension.SetFileCheckSum(hashType, encoding, uri => stream);
}
/// <summary>
/// Set possibly file extension properties from a FileInfo object:
/// - size
/// - checksum
/// </summary>
/// <returns></returns>
public static async Task SetFileExtensionProperties(this FileStacExtension fileStacExtension,
FileInfo file,
HashType hashType = HashType.SHA1,
MultibaseEncoding encoding = MultibaseEncoding.Base16Lower)
{
fileStacExtension.Size = Convert.ToUInt64(file.Length);
await fileStacExtension.SetFileCheckSum(hashType, encoding, uri => file.OpenRead());
}
/// <summary>
/// Encode a byte array to multibase given encoding.
/// </summary>
/// <param name="encoding">Encoding</param>
/// <param name="bytes">Bytes</param>
/// <returns>Encoded string</returns>
public static string Encode(MultibaseEncoding encoding, byte[] bytes)
{
if (!_bases.TryGetValue(encoding, out var @base))
{
throw new NotSupportedException($"{encoding} is not supported.");
}
return(Encode(@base, bytes, true));
}
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 static Multihash Parse(string s, MultibaseEncoding encoding)
{
if (!TryParse(s, encoding, out var mh))
{
throw new FormatException("Not a valid multihash");
}
return(mh);
}
/// <summary>
/// Encode a byte array given encoding (without multibase prefix).
/// </summary>
/// <param name="encoding">Encoding</param>
/// <param name="bytes">Bytes</param>
/// <returns>Encoded string</returns>
public static string EncodeRaw(MultibaseEncoding encoding, byte[] bytes)
{
var @base = _bases[encoding];
if (@base == null)
{
throw new NotSupportedException($"{encoding} is not supported.");
}
return(Encode(@base, bytes, false));
}
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 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);
}
/// <summary>
/// Decode an encoded string using given encoded (without multibase prefix).
/// </summary>
/// <param name="encoding">Encoding</param>
/// <param name="input">Encoded string</param>
/// <returns>Bytes</returns>
public static byte[] DecodeRaw(MultibaseEncoding encoding, string input)
{
if (string.IsNullOrEmpty(input))
{
throw new ArgumentNullException(nameof(input));
}
if (!_bases.TryGetValue(encoding, out var @base))
{
throw new NotSupportedException($"{encoding} is an unknown encoding.");
}
return(@base.Decode(input));
}
public static bool TryParse(string s, out Multihash mh, out MultibaseEncoding encoding)
{
foreach (var _encoding in _encodings)
{
try
{
encoding = _encoding;
if (TryParse(s, encoding, out mh))
{
return(true);
}
}
catch (Exception) { }
}
mh = null;
encoding = (MultibaseEncoding)(-1);
return(false);
}
/// <summary>
/// Add the checksum property of the file extension
/// </summary>
/// <returns></returns>
public static async Task SetFileCheckSum(this FileStacExtension fileStacExtension,
HashType hashType,
MultibaseEncoding encoding,
Func <Uri, Stream> uriStreamer)
{
Multihash mh = null;
using (var stream = uriStreamer(fileStacExtension.StacAsset.Uri))
{
byte[] data = null;
using (var mem = new MemoryStream())
{
await stream.CopyToAsync(mem);
data = mem.ToArray();
fileStacExtension.Size = Convert.ToUInt64(mem.Length);
}
mh = Multihash.Sum(hashType, data);
}
fileStacExtension.Checksum = mh;
}
public string ToString(MultibaseEncoding encoding) => Multibase.EncodeRaw(encoding, _bytes.Value);
