public WalletAddress GetAddress( CurrencyConfig currency, uint account, uint chain, uint index, int keyType) { using var securePublicKey = KeyStorage.GetPublicKey( currency: currency, account: account, chain: chain, index: index, keyType: keyType); if (securePublicKey == null) { return(null); } using var publicKey = securePublicKey.ToUnsecuredBytes(); var address = currency.AddressFromKey(publicKey); return(new WalletAddress { Currency = currency.Name, Address = address, PublicKey = Convert.ToBase64String(publicKey), KeyIndex = new KeyIndex { Account = account, Chain = chain, Index = index }, KeyType = keyType }); }
public LoginProfile ProcessAuthoriztion(HttpContext context, IDictionary <string, string> @params) { var twitterService = new TwitterService(KeyStorage.Get("twitterKey"), KeyStorage.Get("twitterSecret")); if (String.IsNullOrEmpty(context.Request["oauth_token"]) || String.IsNullOrEmpty(context.Request["oauth_verifier"])) { var requestToken = twitterService.GetRequestToken(context.Request.Url.AbsoluteUri); var uri = twitterService.GetAuthorizationUri(requestToken); context.Response.Redirect(uri.ToString(), true); } else { var requestToken = new OAuthRequestToken { Token = context.Request["oauth_token"] }; var accessToken = twitterService.GetAccessToken(requestToken, context.Request["oauth_verifier"]); twitterService.AuthenticateWith(accessToken.Token, accessToken.TokenSecret); var user = twitterService.VerifyCredentials(new VerifyCredentialsOptions()); return(ProfileFromTwitter(user)); } return(new LoginProfile()); }
public static T CreateDesignData <T>(params string[] propertyValues) where T : class { if (typeof(T).Name.Contains("EcKeyPairInfo")) { var seed = Encoding.UTF8.GetBytes(propertyValues.Aggregate((s, s1) => s + s1)); seed = SHA1.Create().ComputeHash(seed); var key = ToHexString(seed); if (!KeyStorage.ContainsKey(key)) { KeyStorage.Add(key, EncryptionSuite.Encryption.EllipticCurveCryptographer.CreateKeyPair(false)); } return(new EncryptionSuite.Contract.EcKeyPairInfo() { TokenLabel = propertyValues[1], ManufacturerId = "Nitrokey", CurveDescription = "brainpoolP320r1 (320 bit)", ECParamsData = StringToByteArray("06092b2403030208010109"), PublicKey = KeyStorage[key], EcIdentifier = new EcIdentifier() { KeyLabel = propertyValues[0], TokenSerialNumber = propertyValues[2] } } as T); } return(default(T)); }
/// <summary> /// Initializes the new instance of the <see cref="ManifestBuilder"/> class. /// </summary> /// <param name="issuerName"></param> /// <param name="issuerXmlPath"></param> /// <param name="assemblyName"></param> /// <param name="directory"></param> /// <param name="keyStore"></param> /// <param name="keyPassword"></param> public ManifestBuilder(string issuerName, string issuerXmlPath, string assemblyName, string directory, KeyStorage keyStore, string keyPassword) : this( issuerName, issuerXmlPath, assemblyName, directory, keyStore, keyPassword, ManifestBuilderConfiguration.Default) { }
public static void Main(string[] args) { #if DEBUG args = new string[] { "SafeBox", "Repo", "watchTest", "Bob" }; #else if (args.Length != 4) { Console.WriteLine("Usage: Watcher.exe <directory path> <repo> <prefix> <recipient key>"); return; } #endif string path = args [0]; Repo repo = Repo.Create(args [1]); string prefix = args [2]; string recipientName = args [3]; Directory.CreateDirectory(path); KeyStorage keyStorage = KeyStorage.Default; PublicKey recipientKey = null; if (recipientName != null) { recipientKey = keyStorage.GetPublic(recipientName); EncryptedRepo er = new EncryptedRepo(repo, keyStorage); er.AddKey(recipientKey); repo = er; } DirectoryWatcher dw = new DirectoryWatcher(path, repo, prefix); dw.Run(); }
static SmsProviderManager() { SmscProvider = new SmscProvider(); ClickatellProvider = new ClickatellProvider(KeyStorage.Get("clickatellapiKey")); ClickatellUSAProvider = new ClickatellProvider(KeyStorage.Get("clickatellUSAapiKey"), KeyStorage.Get("clickatellUSAsender")); TwilioProvider = new TwilioProvider(); }
/// <summary> /// Imports the symmetric key as a clear text. /// </summary> /// <param name="key">The key.</param> public virtual void ImportSymmetricKey( byte[] key) { _hashAlgorithm.Key = key; IsHashKeyInitialized = true; KeyStorage?.PutKey(EncryptHashKey(), KeyLocation); }
static ImportConfiguration() { SupportBoxNetImport = !string.IsNullOrEmpty(KeyStorage.Get("box.net")); SupportGoogleImport = !string.IsNullOrEmpty(KeyStorage.Get("googleConsumerKey")); SupportZohoImport = !string.IsNullOrEmpty(KeyStorage.Get("zoho")); SupportImport = SupportBoxNetImport || SupportGoogleImport || SupportZohoImport; var providers = (WebConfigurationManager.AppSettings["files.thirdparty.enable"] ?? "").Split(new char[] { '|', ',' }, StringSplitOptions.RemoveEmptyEntries); SupportBoxNetInclusion = providers.Contains("boxnet"); SupportDropboxInclusion = providers.Contains("dropbox") && !string.IsNullOrEmpty(KeyStorage.Get("dropboxappkey")) && !string.IsNullOrEmpty(KeyStorage.Get("dropboxappsecret")); SupportGoogleInclusion = providers.Contains("google") && SupportGoogleImport; SupportInclusion = SupportBoxNetInclusion || SupportDropboxInclusion || SupportGoogleInclusion; if (SupportBoxNetImport) { BoxNetApiKey = KeyStorage.Get("box.net"); BoxNetIFrameAddress = KeyStorage.Get("box.net.framehandler"); } if (SupportGoogleImport) { GoogleTokenManager = TokenManagerHolder.Get("google", "googleConsumerKey", "googleConsumerSecret"); } if (SupportZohoImport) { ZohoApiKey = KeyStorage.Get("zoho"); } if (SupportDropboxInclusion) { DropboxAppKey = KeyStorage.Get("dropboxappkey"); DropboxAppSecret = KeyStorage.Get("dropboxappsecret"); } }
public virtual void ImportSymmetricKey( byte[] key) { Symmetric.Key = key; KeyStorage?.PutKey(EncryptSymmetricKey(), KeyLocation); IsSymmetricKeyInitialized = true; }
public static object GetEasyBibCitation(string data) { try { var easyBibappkey = KeyStorage.Get("easyBibappkey"); var jsonBlogInfo = JObject.Parse(data); jsonBlogInfo.Add("key", easyBibappkey); var citationData = jsonBlogInfo.ToString(); var uri = "https://api.citation-api.com/2.0/rest/cite"; const string contentType = "application/json"; const string method = "POST"; var body = citationData; var headers = new Dictionary <string, string>() { }; return(RequestHelper.PerformRequest(uri, contentType, method, body, headers)); } catch (Exception) { return(null); throw; } }
protected void Page_Load(object sender, EventArgs e) { try { var scope = KeyStorage.Get("mail.googleScopes"); var token = GoogleLoginProvider.Auth(HttpContext.Current, scope); var email = GetEmail(token.AccessToken); var emailInfo = new EmailAccessInfo { Email = email, RefreshToken = token.RefreshToken }; SubmitEmailInfo(emailInfo); } catch (ThreadAbortException) { } catch (Exception ex) { ErrorScope = ex.Message; SubmitEmailInfo(new EmailAccessInfo()); } }
private static AuthService ToAuthService(string consumerName, KeyElement consumerKey, KeyElement consumerSecret, KeyElement consumerKeyDefault, KeyElement consumerSecretDefault) { var authService = new AuthService(consumerName); if (consumerKey != null) { authService.WithKey(consumerKey.Name, KeyStorage.Get(consumerKey.Name)); if (KeyStorage.CanSet(consumerKey.Name)) { authService.CanSet = true; } if (consumerKey.Order.HasValue) { authService.Order = consumerKey.Order; } } if (consumerSecret != null) { authService.WithSecret(consumerSecret.Name, KeyStorage.Get(consumerSecret.Name)); if (!authService.CanSet && KeyStorage.CanSet(consumerSecret.Name)) { authService.CanSet = true; } if (!authService.Order.HasValue && consumerSecret.Order.HasValue) { authService.Order = consumerSecret.Order; } } if (consumerKeyDefault != null) { authService.WithKeyDefault(consumerKeyDefault.Name, KeyStorage.Get(consumerKeyDefault.Name)); if (!authService.CanSet && KeyStorage.CanSet(consumerKeyDefault.Name)) { authService.CanSet = true; } if (!authService.Order.HasValue && consumerKeyDefault.Order.HasValue) { authService.Order = consumerKeyDefault.Order; } } if (consumerSecretDefault != null) { authService.WithSecretDefault(consumerSecretDefault.Name, KeyStorage.Get(consumerSecretDefault.Name)); if (!authService.CanSet && KeyStorage.CanSet(consumerSecretDefault.Name)) { authService.CanSet = true; } if (!authService.Order.HasValue && consumerSecretDefault.Order.HasValue) { authService.Order = consumerSecretDefault.Order; } } if (!authService.Order.HasValue) { authService.Order = int.MaxValue; } return(authService); }
private void InitProviders() { IEnumerable <LoginProfile> linkedAccounts = new List <LoginProfile>(); if (SecurityContext.IsAuthenticated) { linkedAccounts = GetLinker().GetLinkedProfiles(SecurityContext.CurrentAccount.ID.ToString()); } var fromOnly = string.IsNullOrWhiteSpace(HttpContext.Current.Request["fromonly"]) ? string.Empty : HttpContext.Current.Request["fromonly"].ToLower(); if (!string.IsNullOrEmpty(GoogleLoginProvider.GoogleOAuth20ClientId) && (string.IsNullOrEmpty(fromOnly) || fromOnly == "google" || fromOnly == "openid")) { AddProvider(ProviderConstants.Google, linkedAccounts); } if (!string.IsNullOrEmpty(FacebookLoginProvider.FacebookOAuth20ClientId) && (string.IsNullOrEmpty(fromOnly) || fromOnly == "facebook")) { AddProvider(ProviderConstants.Facebook, linkedAccounts); } if (!string.IsNullOrEmpty(KeyStorage.Get("twitterKey")) && (string.IsNullOrEmpty(fromOnly) || fromOnly == "twitter")) { AddProvider(ProviderConstants.Twitter, linkedAccounts); } if (!string.IsNullOrEmpty(LinkedInLoginProvider.LinkedInOAuth20ClientId) && (string.IsNullOrEmpty(fromOnly) || fromOnly == "linkedin")) { AddProvider(ProviderConstants.LinkedIn, linkedAccounts); } }
public void TestEncryptedField() { KeyStorage.Shared.ClearKeys(); Environment.SetEnvironmentVariable("MORPHIC_ENC_KEY_PRIMARY", null); Environment.SetEnvironmentVariable("MORPHIC_HASH_SALT_PRIMARY", "SALT1:361e665ef378ab06031806469b7879bd"); var keyName = "TEST_KEY"; var keyData = "8C532F0C2CCE7AF471111285340B6353FCB327DF9AB9F0121731F403E3FFDC7C"; Environment.SetEnvironmentVariable("MORPHIC_ENC_KEY_PRIMARY", $"{keyName}:{keyData}"); Assert.Equal(KeyStorage.HexStringToBytes(keyData), KeyStorage.Shared.GetPrimary().KeyData); string plainText = "thequickbrownfoxjumpedoverthelazydog"; var encryptedField = AssertProperlyEncrypted(keyName, plainText); string decryptedText = encryptedField.Decrypt(); Assert.Equal(plainText, decryptedText); var otherEncryptedField = EncryptedField.FromCombinedString(encryptedField.ToCombinedString()); decryptedText = otherEncryptedField.Decrypt(); Assert.Equal(plainText, decryptedText); AssertProperlyEncrypted(keyName, ""); }
async void Initialize() { var keys = new KeyStorage(); var client = new DropNetClient(await keys.Get("dropbox-apikey"), await keys.Get("dropbox-secret")); client.UseSandbox = true; var token = await client.GetRequestToken(); var url = client.BuildAuthorizeUrl(token, "http://localhost"); var regClient = new WebClientImpl(); browser.SetWebViewClient(regClient); browser.LoadUrl(url); await regClient.Callback.Task; await client.GetAccessToken(); browser.Visibility = ViewStates.Gone; var items = new List<Adaptar.Item>(); foreach (var file in (await client.GetMetaData("/")).Contents.Take(10)) { var buffer = await client.GetThumbnail(file); items.Add( new Adaptar.Item { Title = file.Name, Icon = await BitmapFactory.DecodeByteArrayAsync(buffer, 0, buffer.Length), }); } adapter.Update(items); }
public static ISmsSender CreateSender(string phoneNumber) { // CIS if (Regex.IsMatch(phoneNumber, KeyStorage.Get("sms.CISregex"))) { return new SmscSender { PhoneNumber = phoneNumber } } ; // US else if (Regex.IsMatch(phoneNumber, KeyStorage.Get("sms.USregex"))) { return new USClickatellSender { PhoneNumber = phoneNumber } } ; // Other countries else { return new ClickatellSender { PhoneNumber = phoneNumber } }; }
public void SaveAuthKeys(List <AuthKey> authKeys) { SecurityContext.DemandPermissions(SecutiryConstants.EditPortalSettings); foreach (var authKey in authKeys) { KeyStorage.Set(authKey.Name, authKey.Value); } }
static SmsProviderManager() { SmscProvider = new SmscProvider(); ClickatellProvider = new ClickatellProvider(KeyStorage.Get("clickatellapiKey")); ClickatellUSAProvider = new ClickatellProvider(KeyStorage.Get("clickatellUSAapiKey"), KeyStorage.Get("clickatellUSAsender")); TwilioProvider = new TwilioProvider(TwilioLoginProvider.TwilioAccountSid, TwilioLoginProvider.TwilioAuthToken, KeyStorage.Get("twiliosender")); TwilioSaaSProvider = new TwilioProvider(KeyStorage.Get("twilioSaaSAccountSid"), KeyStorage.Get("twilioSaaSAuthToken"), KeyStorage.Get("twilioSaaSsender")); }
static void Main(string[] args) { CreateJSON cj = new CreateJSON(); KeyStorage ks = new KeyStorage(); ks.GetKeysUser(); ks.GetKeysMachine(); }
public static void Main(string[] args, KeyStorage keyStorage) { //Usage if (args.Length != 4) { throw new HelpException("Missing arguments"); } string sourcePath = args [1]; string repoPath = args [2]; string receipientName = args [3]; //Source if (Directory.Exists(sourcePath) == false) { throw new HelpException("Source directory not found: " + sourcePath); } //Repo Repo repo = Repo.Create(repoPath); //Sender and Recipient keys PrivateKey senderKey = keyStorage.DefaultKey; PublicKey recipientKey = keyStorage.GetPublic(receipientName); //Prepare Route message recording of ChunkID RouteRepo rr = new RouteRepo(repo); //Prepare Encryption EncryptedRepo er = new EncryptedRepo(rr, null); er.AddKey(recipientKey); Console.Write("Generating Tree..."); //Send Tree ChunkHash tree = TreeChunk.GenerateChunk(sourcePath, er); //TreeMessage TreeMessage tm = new TreeMessage(tree, Path.GetDirectoryName(sourcePath)); Chunk tmc = Message.ToChunk(tm, senderKey); ChunkHash tmch = er.WriteChunk(tmc); er.StoreMessage("file", tmch); //RouteMessage RouteMessage rm = rr.RouteMessage; rm.MessageChunkHash = tmch.bytes; rm.To = receipientName; //Store unencrypted RouteMessage Chunk rmChunk = Message.ToChunk(rm); repo.WriteChunk(rmChunk); repo.StoreMessage("route", rmChunk.ChunkHash); Console.WriteLine("RouteMessage Stored"); }
protected override Task <int> OnExecute(CommandLineApplication app) { var keyBytes = Encoding.UTF8.GetBytes(Key); var password = KeyStorage.SaveKey(KeyName, keyBytes); Console.WriteLine($"Password for saved key: {password}"); Console.WriteLine($"Please store this password in order to be able to use this key when executing queries through the CLI."); return(Task.FromResult(0)); }
public static Message FromChunk(Chunk chunk, KeyStorage keyStorage) { if (chunk == null) { return(null); } using (MemoryStream ms = new MemoryStream(chunk.Data)) { byte[] whisper = new byte[7]; if (ms.Read(whisper, 0, whisper.Length) != whisper.Length) { throw new InvalidDataException("Header not right length"); } if (Encoding.ASCII.GetString(whisper) != "Whisper") { throw new InvalidDataException("Missing header"); } MessageHeader header = MessageHeader.Deserialize(ProtocolParser.ReadBytes(ms)); byte[] messageBytes = ProtocolParser.ReadBytes(ms); Message message; switch (header.MessageId) { case 1: message = TreeMessage.Deserialize(messageBytes); break; case 2: message = RouteMessage.Deserialize(messageBytes); break; case 3: message = ListMessage.Deserialize(messageBytes); break; default: throw new NotImplementedException(); } //Verify signature if (header.Signature != null) { foreach (PublicKey key in keyStorage.PublicKeys) { if (key.Verify(messageBytes, header.Signature)) { message.Signature = key; break; } } } return(message); } }
// This method gets called by the runtime. Use this method to add services to the container. // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940 public void ConfigureServices(IServiceCollection services) { services.Configure <MorphicSettings>(Configuration.GetSection("MorphicSettings")); services.AddSingleton <MorphicSettings>(serviceProvider => serviceProvider.GetRequiredService <IOptions <MorphicSettings> >().Value); services.Configure <DatabaseSettings>(Configuration.GetSection("DatabaseSettings")); services.AddSingleton <DatabaseSettings>(serviceProvider => serviceProvider.GetRequiredService <IOptions <DatabaseSettings> >().Value); services.Configure <EmailSettings>(Configuration.GetSection("EmailSettings")); services.AddSingleton <EmailSettings>(serviceProvider => serviceProvider.GetRequiredService <IOptions <EmailSettings> >().Value); services.Configure <KeyStorageSettings>(Configuration.GetSection("KeyStorageSettings")); services.AddSingleton <KeyStorageSettings>(serviceProvider => serviceProvider.GetRequiredService <IOptions <KeyStorageSettings> >().Value); services.AddSingleton <KeyStorage>(serviceProvider => KeyStorage.CreateShared(serviceProvider.GetRequiredService <KeyStorageSettings>(), serviceProvider.GetRequiredService <ILogger <KeyStorage> >())); services.AddSingleton <Database>(); services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>(); services.AddSingleton <IRecaptcha, MockRecaptcha>(); services.AddSingleton <IBackgroundJobClient, MockBackgroundJobClient>(); services.AddSingleton <StripeSettings>(new StripeSettings() { WebhookSecret = "webhooksecret" }); services.AddSingleton <IPaymentProcessor, MockPaymentProcessor>(); services.AddSingleton <Plans>(new Plans( new Plan[] { new Plan() { Id = "testplan1", IsDefault = true, IsActive = true, MemberLimit = 5, Months = 1, Price = 500, Currency = "USD" }, new Plan() { Id = "testplan2", IsActive = true, MemberLimit = 10, Months = 1, Price = 1000, Currency = "USD" }, new Plan() { Id = "testplan3", IsActive = false, MemberLimit = 5, Months = 1, Price = 600, Currency = "USD" } } )); services.AddRouting(); services.AddEndpoints(); }
public Task <byte[]> SignAsync( byte[] data, WalletAddress address, CurrencyConfig currency, CancellationToken cancellationToken = default) { if (data == null) { throw new ArgumentNullException(nameof(data)); } if (address == null) { throw new ArgumentNullException(nameof(address)); } Log.Verbose("Sign request for data {@data} with key for address {@address}", data.ToHexString(), address.Address); if (IsLocked) { Log.Warning("Wallet locked"); return(Task.FromResult <byte[]>(null)); } if (address.KeyIndex == null) { Log.Error($"Can't find private key for address {address.Address}"); return(Task.FromResult <byte[]>(null)); } var signature = KeyStorage.SignMessage( currency: currency, data: data, keyIndex: address.KeyIndex, keyType: address.KeyType); Log.Verbose("Data signature in base64: {@signature}", Convert.ToBase64String(signature)); if (!KeyStorage.VerifyMessage( currency: currency, data: data, signature: signature, keyIndex: address.KeyIndex, keyType: address.KeyType)) { Log.Error("Signature verify error"); return(Task.FromResult <byte[]>(null)); } Log.Verbose("Data successfully signed"); return(Task.FromResult(signature)); }
public void SaveAuthKeys(List <AuthKey> authKeys) { SecurityContext.DemandPermissions(SecutiryConstants.EditPortalSettings); foreach (var authKey in authKeys.Where(authKey => KeyStorage.Get(authKey.Name) != authKey.Value)) { KeyStorage.Set(authKey.Name, authKey.Value); } MessageService.Send(HttpContext.Current.Request, MessageAction.AuthorizationKeysSetting); }
static Global() { const StringComparison cmp = StringComparison.InvariantCultureIgnoreCase; EnableUploadFilter = Boolean.TrueString.Equals(WebConfigurationManager.AppSettings["files.upload-filter"] ?? "false", cmp); EnableEmbedded = Boolean.TrueString.Equals(WebConfigurationManager.AppSettings["files.docservice.embedded"] ?? "true", cmp); BitlyUrl = KeyStorage.Get("bitly-url"); }
private void AddToKeyStorage(string strKey, string strValue) { if (!KeyStorage.ContainsKey(strKey)) { KeyStorage.Add(strKey, strValue); } else { KeyStorage[strKey] = strValue; } }
public bool SaveAuthKeys(List <AuthKey> authKeys) { SecurityContext.DemandPermissions(SecutiryConstants.EditPortalSettings); if (!SetupInfo.IsVisibleSettings(ManagementType.ThirdPartyAuthorization.ToString())) { throw new BillingException(Resource.ErrorNotAllowedOption, "ThirdPartyAuthorization"); } var changed = false; var mapKeys = new Dictionary <string, List <KeyElement> >(); foreach (var authKey in authKeys.Where(authKey => KeyStorage.Get(authKey.Name) != authKey.Value)) { var keyElement = ConsumerConfigurationSection.GetSection().Keys.GetKey(authKey.Name); if (keyElement != null && Providers.ContainsKey(keyElement.ConsumerName)) { RemoveOldNumberFromTwilio(Providers[keyElement.ConsumerName]); if (!string.IsNullOrEmpty(authKey.Value)) { if (!mapKeys.ContainsKey(keyElement.ConsumerName)) { mapKeys.Add(keyElement.ConsumerName, new List <KeyElement>()); } mapKeys[keyElement.ConsumerName].Add(keyElement); } } KeyStorage.Set(authKey.Name, authKey.Value); changed = true; } foreach (var providerKeys in mapKeys) { if (!Providers[providerKeys.Key].ValidateKeys()) { foreach (var providerKey in providerKeys.Value) { KeyStorage.Set(providerKey.Name, null); } throw new ArgumentException(Resource.ErrorBadKeys); } } if (changed) { MessageService.Send(HttpContext.Current.Request, MessageAction.AuthorizationKeysSetting); } return(changed); }
public LoginProfile GetLoginProfile(string accessToken) { var twitterService = new TwitterService(KeyStorage.Get("twitterKey"), KeyStorage.Get("twitterSecret")); //??? tokenSecret twitterService.AuthenticateWith(accessToken, null); var user = twitterService.VerifyCredentials(new VerifyCredentialsOptions()); return(ProfileFromTwitter(user)); }
public static TwitterApiInfo GetTwitterApiInfoForCurrentUser() { TwitterApiInfo apiInfo = new TwitterApiInfo { ConsumerKey = KeyStorage.Get(SocialMediaConstants.ConfigKeyTwitterConsumerKey), ConsumerSecret = KeyStorage.Get(SocialMediaConstants.ConfigKeyTwitterConsumerSecretKey) }; SetDefaultTokens(apiInfo); return(apiInfo); }
public Task <byte[]> SignHashAsync( byte[] hash, WalletAddress address, CurrencyConfig currencyConfig, CancellationToken cancellationToken = default) { if (hash == null) { throw new ArgumentNullException(nameof(hash)); } if (address == null) { throw new ArgumentNullException(nameof(address)); } Log.Verbose("Sign request for hash {@hash}", hash.ToHexString()); if (IsLocked) { Log.Warning("Wallet locked"); return(Task.FromResult <byte[]>(null)); } if (address.KeyIndex == null) { Log.Error($"Can't find private key for address {address.Address}"); return(Task.FromResult <byte[]>(null)); } var signature = KeyStorage.SignHash( currency: currencyConfig, hash: hash, keyIndex: address.KeyIndex, keyType: address.KeyType); Log.Verbose("Hash signature in base64: {@signature}", Convert.ToBase64String(signature)); if (!KeyStorage.VerifyHash( currency: currencyConfig, hash: hash, signature: signature, keyIndex: address.KeyIndex, keyType: address.KeyType)) { Log.Error("Signature verify error"); return(Task.FromResult <byte[]>(null)); } Log.Verbose("Hash successfully signed"); return(Task.FromResult(signature)); }