private static void GeneratePublicPrivateKeys() { // Generate keys for signing. var mnemonicForSigningKey = new Mnemonic(Wordlist.English, WordCount.Twelve); PubKey signingPubKey = mnemonicForSigningKey.DeriveExtKey().PrivateKey.PubKey; // Generate keys for migning. var tool = new KeyTool(new DataFolder(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location))); Key key = tool.GeneratePrivateKey(); string savePath = tool.GetPrivateKeySavePath(); tool.SavePrivateKey(key); PubKey miningPubKey = key.PubKey; Console.WriteLine($"-----------------------------------------------------------------------------"); Console.WriteLine($"-- Please give the following 2 public keys to the federation administrator --"); Console.WriteLine($"-----------------------------------------------------------------------------"); Console.WriteLine($"1. Your signing pubkey: {Encoders.Hex.EncodeData(signingPubKey.ToBytes(false))}"); Console.WriteLine($"2. Your mining pubkey: {Encoders.Hex.EncodeData(miningPubKey.ToBytes(false))}"); Console.WriteLine(Environment.NewLine); Console.WriteLine($"------------------------------------------------------------------------------------------"); Console.WriteLine($"-- Please keep the following 12 words for yourself and note them down in a secure place --"); Console.WriteLine($"------------------------------------------------------------------------------------------"); Console.WriteLine($"Your signing mnemonic: {string.Join(" ", mnemonicForSigningKey.Words)}"); Console.WriteLine(Environment.NewLine); Console.WriteLine($"------------------------------------------------------------------------------------------------------------"); Console.WriteLine($"-- Please save the following file in a secure place, you'll need it when the federation has been created. --"); Console.WriteLine($"------------------------------------------------------------------------------------------------------------"); Console.WriteLine($"File path: {savePath}"); Console.WriteLine(Environment.NewLine); }
public Task Invoke(HttpContext context) { string token = ""; if (context.Request.Cookies.TryGetValue("MRCTOKEN", out token)) { string userinfo = EncryptHelper.DesDecrypt(token, KeyTool.GetEncryptKey()); string orginInfo = RedisHelper.Get(userinfo); if (orginInfo.IsNullOrEmpty()) { context.Items["islogin"] = false; return(this._next(context)); } ; AdminSession userSession = JsonHelper.Deserialize <AdminSession>(orginInfo); if (context.GetClientIP() != userSession.LoginIP) { context.Items["islogin"] = false; } else { context.Items["user"] = userSession; context.Items["islogin"] = true; } } return(this._next(context)); }
public void GetMiningTimestamp() { var tool = new KeyTool(null); Key key = tool.GeneratePrivateKey(); this.network = new TestPoANetwork(new List <PubKey>() { tool.GeneratePrivateKey().PubKey, key.PubKey, tool.GeneratePrivateKey().PubKey }); var fedManager = new FederationManager(NodeSettings.Default(this.network), this.network, new LoggerFactory()); this.slotsManager = new SlotsManager(this.network, fedManager, new LoggerFactory()); List <PubKey> fedKeys = this.consensusOptions.FederationPublicKeys; uint roundStart = this.consensusOptions.TargetSpacingSeconds * (uint)fedKeys.Count * 5; fedManager.SetPrivatePropertyValue(nameof(FederationManager.IsFederationMember), true); fedManager.SetPrivatePropertyValue(nameof(FederationManager.FederationMemberKey), key); Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart)); Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart + 4)); roundStart += this.consensusOptions.TargetSpacingSeconds * (uint)fedKeys.Count; Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - 5)); Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - this.consensusOptions.TargetSpacingSeconds + 1)); Assert.True(this.slotsManager.IsValidTimestamp(this.slotsManager.GetMiningTimestamp(roundStart - 5))); }
/// <summary> /// /// </summary> /// <param name="oldPassword">明文</param> /// <param name="newPassword">明文</param> public void ChangePassword(string userID, string oldPassword, string newPassword) { //EncryptHelper.DesEncrypt(newPassword); Sys_UserLogOn userLogOn = this.DbContext.Query <Sys_UserLogOn>().Where(a => a.UserId == userID).First(); string encryptedOldPassword = EncryptHelper.DesEncrypt(oldPassword, userLogOn.UserSecretkey); if (encryptedOldPassword != userLogOn.UserPassword) { throw new InvalidInputException("旧密码不正确"); } string newUserSecretkey = KeyTool.GetEncryptKey(); string newEncryptedPassword = EncryptHelper.DesEncrypt(newPassword, newUserSecretkey); this.DbContext.DoWithTransaction(() => { this.DbContext.Update <Sys_UserLogOn>(a => a.UserId == userID, a => new Sys_UserLogOn() { UserSecretkey = newUserSecretkey, UserPassword = newEncryptedPassword }); }); }
public void GetMiningTimestamp() { var tool = new KeyTool(new DataFolder(string.Empty)); Key key = tool.GeneratePrivateKey(); this.network = new TestPoANetwork(new List <PubKey>() { tool.GeneratePrivateKey().PubKey, key.PubKey, tool.GeneratePrivateKey().PubKey }); FederationManager fedManager = PoATestsBase.CreateFederationManager(this, this.network, new ExtendedLoggerFactory()); this.slotsManager = new SlotsManager(this.network, fedManager, new LoggerFactory()); List <PubKey> fedKeys = this.federationManager.GetFederationMembers(); uint roundStart = this.consensusOptions.TargetSpacingSeconds * (uint)fedKeys.Count * 5; fedManager.SetPrivatePropertyValue(nameof(FederationManager.IsFederationMember), true); fedManager.SetPrivatePropertyValue(nameof(FederationManager.FederationMemberKey), key); Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart)); Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart + 4)); roundStart += this.consensusOptions.TargetSpacingSeconds * (uint)fedKeys.Count; Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - 5)); Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - this.consensusOptions.TargetSpacingSeconds + 1)); Assert.True(this.slotsManager.IsValidTimestamp(this.slotsManager.GetMiningTimestamp(roundStart - 5))); }
public async Task <PubKey> JoinFederationAsync(JoinFederationRequestModel request, CancellationToken cancellationToken) { // Get the address pub key hash. var address = BitcoinAddress.Create(request.CollateralAddress, this.counterChainSettings.CounterChainNetwork); KeyId addressKey = PayToPubkeyHashTemplate.Instance.ExtractScriptPubKeyParameters(address.ScriptPubKey); // Get mining key. var keyTool = new KeyTool(this.settings.DataFolder); Key minerKey = keyTool.LoadPrivateKey(); if (minerKey == null) { throw new Exception($"The private key file ({KeyTool.KeyFileDefaultName}) has not been configured."); } var expectedCollateralAmount = CollateralFederationMember.GetCollateralAmountForPubKey(this.network, minerKey.PubKey); Money collateralAmount = new Money(expectedCollateralAmount, MoneyUnit.BTC); var joinRequest = new JoinFederationRequest(minerKey.PubKey, collateralAmount, addressKey); // Populate the RemovalEventId. var collateralFederationMember = new CollateralFederationMember(minerKey.PubKey, false, joinRequest.CollateralAmount, request.CollateralAddress); byte[] federationMemberBytes = (this.network.Consensus.ConsensusFactory as CollateralPoAConsensusFactory).SerializeFederationMember(collateralFederationMember); var votingManager = this.fullNode.NodeService <VotingManager>(); Poll poll = votingManager.GetFinishedPolls().FirstOrDefault(x => x.IsExecuted && x.VotingData.Key == VoteKey.KickFederationMember && x.VotingData.Data.SequenceEqual(federationMemberBytes)); joinRequest.RemovalEventId = (poll == null) ? Guid.Empty : new Guid(poll.PollExecutedBlockData.Hash.ToBytes().TakeLast(16).ToArray()); // Get the signature by calling the counter-chain "signmessage" API. var signMessageRequest = new SignMessageRequest() { Message = joinRequest.SignatureMessage, WalletName = request.CollateralWalletName, Password = request.CollateralWalletPassword, ExternalAddress = request.CollateralAddress }; var walletClient = new WalletClient(this.loggerFactory, this.httpClientFactory, $"http://{this.counterChainSettings.CounterChainApiHost}", this.counterChainSettings.CounterChainApiPort); string signature = await walletClient.SignMessageAsync(signMessageRequest, cancellationToken); if (signature == null) { throw new Exception("Operation was cancelled during call to counter-chain to sign the collateral address."); } joinRequest.AddSignature(signature); var walletTransactionHandler = this.fullNode.NodeService <IWalletTransactionHandler>(); var encoder = new JoinFederationRequestEncoder(this.loggerFactory); Transaction trx = JoinFederationRequestBuilder.BuildTransaction(walletTransactionHandler, this.network, joinRequest, encoder, request.WalletName, request.WalletAccount, request.WalletPassword); var walletService = this.fullNode.NodeService <IWalletService>(); await walletService.SendTransaction(new SendTransactionRequest(trx.ToHex()), cancellationToken); return(minerKey.PubKey); }
public PoAHeaderSignatureTests() { string testRootPath = Path.Combine(Path.GetTempPath(), this.GetType().Name); var dataFolder = new DataFolder(testRootPath); this.tool = new KeyTool(dataFolder); this.validator = new PoABlockHeaderValidator(new ExtendedLoggerFactory()); }
public KeyToolTests() { string testRootPath = Path.Combine(Path.GetTempPath(), this.GetType().Name + "_" + nameof(this.CanSaveLoadKey)); Directory.CreateDirectory(testRootPath); this.dataFolder = new DataFolder(testRootPath); this.tool = new KeyTool(this.dataFolder); }
public void GetMiningTimestamp() { var tool = new KeyTool(new DataFolder(string.Empty)); Key key = tool.GeneratePrivateKey(); this.network = new TestPoANetwork(new List <PubKey>() { tool.GeneratePrivateKey().PubKey, key.PubKey, tool.GeneratePrivateKey().PubKey }); (IFederationManager fedManager, IFederationHistory federationHistory) = PoATestsBase.CreateFederationManager(this, this.network, new ExtendedLoggerFactory(), new Signals.Signals(new LoggerFactory(), null)); var header = new BlockHeader(); this.chainIndexer.Setup(x => x.Tip).Returns(new ChainedHeader(header, header.GetHash(), 0)); this.slotsManager = new SlotsManager(this.network, fedManager, federationHistory, this.chainIndexer.Object); List <IFederationMember> federationMembers = fedManager.GetFederationMembers(); uint roundStart = this.consensusOptions.TargetSpacingSeconds * (uint)federationMembers.Count * 5; fedManager.SetPrivatePropertyValue(typeof(FederationManager), nameof(IFederationManager.CurrentFederationKey), key); fedManager.SetPrivatePropertyValue(typeof(FederationManager), nameof(this.federationManager.IsFederationMember), true); Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart)); Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart + 4)); roundStart += this.consensusOptions.TargetSpacingSeconds * (uint)federationMembers.Count; Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - 5)); Assert.Equal(roundStart + this.consensusOptions.TargetSpacingSeconds, this.slotsManager.GetMiningTimestamp(roundStart - this.consensusOptions.TargetSpacingSeconds + 1)); Assert.True(this.slotsManager.IsValidTimestamp(this.slotsManager.GetMiningTimestamp(roundStart - 5))); uint thisTurnTimestamp = roundStart + this.consensusOptions.TargetSpacingSeconds; uint nextTurnTimestamp = thisTurnTimestamp + this.consensusOptions.TargetSpacingSeconds * (uint)federationMembers.Count; // If we are past our last timestamp's turn, always give us the NEXT timestamp. uint justPastOurTurnTime = thisTurnTimestamp + (this.consensusOptions.TargetSpacingSeconds / 2) + 1; Assert.Equal(nextTurnTimestamp, this.slotsManager.GetMiningTimestamp(justPastOurTurnTime)); // If we are only just past our last timestamp, but still in the "range" and we haven't mined a block yet, get THIS turn's timestamp. Assert.Equal(thisTurnTimestamp, this.slotsManager.GetMiningTimestamp(thisTurnTimestamp + 1)); // If we are only just past our last timestamp, but we've already mined a block there, then get the NEXT turn's timestamp. header = new BlockHeader { Time = thisTurnTimestamp }; Mock.Get(federationHistory).Setup(x => x.GetFederationMemberForBlock(It.IsAny <ChainedHeader>())).Returns <ChainedHeader>((chainedHeader) => { return(federationMembers[1]); }); this.chainIndexer.Setup(x => x.Tip).Returns(new ChainedHeader(header, header.GetHash(), 0)); this.slotsManager = new SlotsManager(this.network, fedManager, federationHistory, this.chainIndexer.Object); Assert.Equal(nextTurnTimestamp, this.slotsManager.GetMiningTimestamp(thisTurnTimestamp + 1)); }
public CoreNode CreateWhitelistedContractPoANode(SmartContractsPoARegTest network, int nodeIndex) { string dataFolder = this.GetNextDataFolderName(); CoreNode node = this.CreateNode(new WhitelistedContractPoARunner(dataFolder, network, this.TimeProvider), "poa.conf"); var settings = new NodeSettings(network, args: new string[] { "-conf=poa.conf", "-datadir=" + dataFolder }); var tool = new KeyTool(settings.DataFolder); tool.SavePrivateKey(network.FederationKeys[nodeIndex]); return(node); }
private bool CreateFederationKey() { var keyFilePath = Path.Combine(this.rootDataDir, this.sidechainNetwork.RootFolderName, this.sidechainNetwork.Name, KeyTool.KeyFileDefaultName); if (File.Exists(keyFilePath)) { Console.WriteLine($"Your masternode public key file already exists."); return(true); } Console.Clear(); Console.WriteLine($"Your masternode public key will now be generated."); string publicKeyPassphrase; do { Console.WriteLine($"Please enter a passphrase (this can be anything, but please write it down):"); publicKeyPassphrase = Console.ReadLine(); if (!string.IsNullOrEmpty(publicKeyPassphrase)) { break; } Console.WriteLine("ERROR: Please ensure that you enter a valid passphrase."); } while (true); // Generate keys for mining. var tool = new KeyTool(keyFilePath); Key key = tool.GeneratePrivateKey(); string savePath = tool.GetPrivateKeySavePath(); tool.SavePrivateKey(key); PubKey miningPubKey = key.PubKey; Console.WriteLine($"Your Masternode Public Key (PubKey) is: {Encoders.Hex.EncodeData(miningPubKey.ToBytes(false))}"); if (publicKeyPassphrase != null) { Console.WriteLine(Environment.NewLine); Console.WriteLine($"Your passphrase: {publicKeyPassphrase}"); } Console.WriteLine(Environment.NewLine); Console.WriteLine($"It has been saved in the root Cirrus data folder: {savePath}"); Console.WriteLine($"Please ensure that you take a backup of this file."); return(true); }
public CoreNode CreatePoANode(PoANetwork network, Key key) { string dataFolder = this.GetNextDataFolderName(); CoreNode node = this.CreateNode(new PoANodeRunner(dataFolder, network, this.TimeProvider), "poa.conf"); var settings = new NodeSettings(network, args: new string[] { "-conf=poa.conf", "-datadir=" + dataFolder }); var tool = new KeyTool(settings.DataFolder); tool.SavePrivateKey(key); return(node); }
public CoreNode CreateSidechainNode(Network network, Key key) { var agentName = $"sidechain{Interlocked.Increment(ref agentCount)}"; string dataFolder = this.GetNextDataFolderName(agentName); CoreNode node = this.CreateNode(new SidechainNodeRunner(dataFolder, agentName, network, this.TimeProvider), "poa.conf"); var settings = new NodeSettings(network, args: new string[] { "-conf=poa.conf", "-datadir=" + dataFolder }); var tool = new KeyTool(settings.DataFolder); tool.SavePrivateKey(key); return(node); }
public void CreateDebugKeyStoreWithStrongPassword() { string keyfile = Path.Combine(TestName, "debug.keystore"); string pass = "******"; if (File.Exists(keyfile)) { File.Delete(keyfile); } var task = new AndroidCreateDebugKey { BuildEngine = engine, KeyStore = keyfile, StorePass = pass, KeyAlias = "teststringkey", KeyPass = pass, KeyAlgorithm = "RSA", Validity = 10000, StoreType = "pkcs12", Command = "-genkeypair", ToolPath = keyToolPath, }; Assert.IsTrue(task.Execute(), "Task should have succeeded."); Assert.AreEqual(0, errors.Count, "Task should have no errors."); Assert.AreEqual(0, warnings.Count, "Task should have no warnings."); Assert.AreEqual(0, task.ExitCode, "ExitCode should have been 0"); messages.Clear(); var keyToolTask = new KeyTool { BuildEngine = engine, KeyStore = keyfile, StorePass = pass, KeyAlias = "teststringkey", KeyPass = pass, Command = "-list", ToolPath = keyToolPath, }; Assert.IsTrue(keyToolTask.Execute(), "Task should have succeeded."); Assert.AreEqual(0, errors.Count, "Task should have no errors."); Assert.AreEqual(0, warnings.Count, "Task should have no warnings."); Assert.AreEqual(0, task.ExitCode, "ExitCode should have been 0"); string output = string.Join(" ", messages.Select(x => x.Message)); Assert.IsTrue(output.Contains("Certificate fingerprint (SHA"), "Certificate SHA1 or SHA-256 should have been printed."); }
private static void GeneratePublicPrivateKeys(string passphrase, string keyPath, bool isMultiSigOutput = true) { // Generate keys for signing. var mnemonicForSigningKey = new Mnemonic(Wordlist.English, WordCount.Twelve); PubKey signingPubKey = mnemonicForSigningKey.DeriveExtKey(passphrase).PrivateKey.PubKey; // Generate keys for migning. var tool = new KeyTool(keyPath); Key key = tool.GeneratePrivateKey(); string savePath = tool.GetPrivateKeySavePath(); tool.SavePrivateKey(key); PubKey miningPubKey = key.PubKey; Console.WriteLine($"Your Masternode Public Key: {Encoders.Hex.EncodeData(miningPubKey.ToBytes(false))}"); Console.WriteLine($"-----------------------------------------------------------------------------"); if (isMultiSigOutput) { Console.WriteLine( $"Your Masternode Signing Key: {Encoders.Hex.EncodeData(signingPubKey.ToBytes(false))}"); Console.WriteLine(Environment.NewLine); Console.WriteLine( $"------------------------------------------------------------------------------------------"); Console.WriteLine( $"-- Please keep the following 12 words for yourself and note them down in a secure place --"); Console.WriteLine( $"------------------------------------------------------------------------------------------"); Console.WriteLine($"Your signing mnemonic: {string.Join(" ", mnemonicForSigningKey.Words)}"); } if (passphrase != null) { Console.WriteLine(Environment.NewLine); Console.WriteLine($"Your passphrase: {passphrase}"); } Console.WriteLine(Environment.NewLine); Console.WriteLine($"------------------------------------------------------------------------------------------------------------"); Console.WriteLine($"-- Please save the following file in a secure place, you'll need it when the federation has been created. --"); Console.WriteLine($"------------------------------------------------------------------------------------------------------------"); Console.WriteLine($"File path: {savePath}"); Console.WriteLine(Environment.NewLine); }
public void SignatureIsValidated() { var validationContext = new ValidationContext() { ChainedHeaderToValidate = this.currentHeader }; var ruleContext = new RuleContext(validationContext, DateTimeOffset.Now); Key randomKey = new KeyTool(new DataFolder(string.Empty)).GeneratePrivateKey(); this.poaHeaderValidator.Sign(randomKey, this.currentHeader.Header as PoABlockHeader); Assert.Throws <ConsensusErrorException>(() => this.signatureRule.Run(ruleContext)); this.poaHeaderValidator.Sign(key, this.currentHeader.Header as PoABlockHeader); this.signatureRule.Run(ruleContext); }
private static bool RequiresKeyGeneration(NodeSettings nodeSettings) { bool generateSetting = nodeSettings.ConfigReader.GetOrDefault("generateKeyPair", false); if (generateSetting) { return(true); } var tool = new KeyTool(nodeSettings.DataFolder); if (tool.LoadPrivateKey() == null) { return(true); } return(false); }
public void ListSuccessWithPassword() { GetValidKeyStore(); var task = new KeyTool { BuildEngine = engine, KeyStore = temp, StorePass = "******", KeyAlias = "mykey", KeyPass = "******", Command = "-list", ToolPath = keyToolPath, }; Assert.IsTrue(task.Execute(), "Task should have succeeded."); Assert.AreEqual(0, errors.Count, "Task should have no errors."); Assert.AreEqual(0, warnings.Count, "Task should have no warnings."); }
public void ListEmptyKey() { var task = new KeyTool { BuildEngine = engine, KeyStore = temp, StorePass = "******", KeyAlias = "mykey", KeyPass = "******", Command = "-list", ToolPath = keyToolPath, }; Assert.IsFalse(task.Execute(), "Task should have failed."); Assert.AreEqual(1, errors.Count, "Task should have one error."); Assert.AreEqual(0, warnings.Count); var error = errors [0]; Assert.AreEqual($"keytool error: java.lang.Exception: Keystore file exists, but is empty: {temp}", error.Message); Assert.AreEqual("ANDKT0000", error.Code); }
public void SignatureIsValidated() { var validationContext = new ValidationContext() { ChainedHeaderToValidate = this.currentHeader }; var ruleContext = new RuleContext(validationContext, DateTimeOffset.Now); Key randomKey = new KeyTool(new DataFolder(string.Empty)).GeneratePrivateKey(); this.poaHeaderValidator.Sign(randomKey, this.currentHeader.Header as PoABlockHeader); this.chainState.ConsensusTip = new ChainedHeader(this.network.GetGenesis().Header, this.network.GetGenesis().GetHash(), 0); Assert.Throws <ConsensusErrorException>(() => this.signatureRule.RunAsync(ruleContext).GetAwaiter().GetResult()); this.poaHeaderValidator.Sign(key, this.currentHeader.Header as PoABlockHeader); this.signatureRule.RunAsync(ruleContext).GetAwaiter().GetResult(); }
/// <summary> /// This locates the required discount, Purchase or Sale. /// </summary> /// <param name="discountFullyLoaded"></param> /// <param name="discountType"></param> /// <returns></returns> private Discount FindGivenDiscount(Discount discountFullyLoaded, DiscountTypeENUM discountType) { //Initialize the DALs //DiscountDAL discountDAL = new DiscountDAL(_db, _user); DiscountPrecedenceDAL discountPrecedenceDAL = new DiscountPrecedenceDAL(_db, _user); List <DiscountPrecedence> discountPrecedenceList = new List <DiscountPrecedence>(); switch (discountType) { case DiscountTypeENUM.Unknown: return(null); case DiscountTypeENUM.Sale: discountPrecedenceList = discountPrecedenceDAL.FindAllRulesByRankSale().ToList(); break; case DiscountTypeENUM.Purchase: discountPrecedenceList = discountPrecedenceDAL.FindAllRulesByRankPurchase().ToList(); break; default: return(null); } //now search them according to the precede if (!discountPrecedenceList.IsNullOrEmpty()) { //Break out of this loop if a discount is found foreach (var rule in discountPrecedenceList) { //Load the rule into the fully loaded Discount for which we are checking KeyTool k = new KeyTool(discountFullyLoaded, rule.DiscountRuleEnum); Discount discountFound = FindForDiscountKey(k.Key); return(discountFound); } } return(null); }
private static void GenerateFederationKey(DataFolder dataFolder) { var tool = new KeyTool(dataFolder); Key key = tool.GeneratePrivateKey(); string savePath = tool.GetPrivateKeySavePath(); tool.SavePrivateKey(key); var stringBuilder = new StringBuilder(); stringBuilder.AppendLine($"Federation key pair was generated and saved to {savePath}."); stringBuilder.AppendLine("Make sure to back it up!"); stringBuilder.AppendLine($"Your public key is {key.PubKey}."); stringBuilder.AppendLine(); stringBuilder.AppendLine("Press eny key to exit..."); Console.WriteLine(stringBuilder.ToString()); Console.ReadKey(); }
public MainWindowViewModel(Window window, KeyTool keyTool, CommandExecutor executor, TemplatesModule templatesModule) { _window = window ?? throw new ArgumentNullException(nameof(window)); _keyTool = keyTool ?? throw new ArgumentNullException(nameof(keyTool)); _executor = executor ?? throw new ArgumentNullException(nameof(executor)); _templatesModule = templatesModule ?? throw new ArgumentNullException(nameof(templatesModule)); _executor.LogMessage += PrintMessage; this.WhenAnyValue(x => x.BundlePath, x => x.ApksPath) .Where(t => string.IsNullOrWhiteSpace(t.Item2)) .Where(t => !string.IsNullOrWhiteSpace(t.Item1)) .Where(t => string.Equals(Path.GetExtension(t.Item1) !.Substring(1), ExtAab)) .Select(t => Path.ChangeExtension(t.Item1, ExtApks)) .Subscribe(path => ApksPath = path); this.WhenAnyValue(x => x.KeystorePath, x => x.KeystorePassword) .Select(x => new { Path = x.Item1, Pass = x.Item2 }) .Where(x => !string.IsNullOrWhiteSpace(x.Path)) .Where(x => !string.IsNullOrWhiteSpace(x.Pass)) .Where(x => (File.GetAttributes(x.Path) & FileAttributes.Directory) != FileAttributes.Directory) .Where(x => File.Exists(x.Path)) .Subscribe(x => UpdateAliases()); _executeModes = new[] { ExecuteMode.BuildApks, ExecuteMode.InstallApks, ExecuteMode.ShowApkSize }; ExecuteModesNames = new ObservableCollection <string>(_executeModes.Select(m => m.GetModeName())); AvailableAliases = new ObservableCollection <string>(); _isOnBuildMode = this.WhenAnyValue(x => x.SelectedExecuteModeIndex) .Select(index => _executeModes[index]) .Select(mode => mode == ExecuteMode.BuildApks) .ToProperty(this, x => x.IsOnBuildMode); }
private static void GenerateServiceNodeKey(NodeSettings nodeSettings) { var tool = new KeyTool(nodeSettings.DataFolder); Key key = tool.GeneratePrivateKey(); string savePath = tool.GetPrivateKeySavePath(); tool.SavePrivateKey(key); var stringBuilder = new StringBuilder(); stringBuilder.AppendLine($"ServiceNode key pair was generated and saved to {savePath}."); stringBuilder.AppendLine("Make sure to back it up!"); stringBuilder.AppendLine($"Your public key is {key.PubKey}."); stringBuilder.AppendLine(); stringBuilder.AppendLine("You can now restart the node to use the key pair. If you need to re-generate add generateKeyPair to settings"); stringBuilder.AppendLine("Press eny key to exit..."); Console.WriteLine(stringBuilder.ToString()); Console.ReadKey(); }
public void ListInvalidAlias() { GetValidKeyStore(); var task = new KeyTool { BuildEngine = engine, KeyStore = temp, StorePass = "******", KeyAlias = "asdf", KeyPass = "******", Command = "-list", ToolPath = keyToolPath, }; Assert.IsFalse(task.Execute(), "Task should have failed."); Assert.AreEqual(1, errors.Count, "Task should have one error."); Assert.AreEqual(0, warnings.Count, "Task should have no warnings."); var error = errors [0]; Assert.AreEqual($"keytool error: java.lang.Exception: Alias <{task.KeyAlias}> does not exist", error.Message); Assert.AreEqual("ANDKT0000", error.Code); }
public void ListInvalidPassword() { GetValidKeyStore(); var task = new KeyTool { BuildEngine = engine, KeyStore = temp, StorePass = "******", KeyAlias = "mykey", KeyPass = "******", Command = "-list", ToolPath = keyToolPath, }; Assert.IsFalse(task.Execute(), "Task should have failed."); Assert.AreEqual(1, errors.Count, "Task should have one error."); Assert.AreEqual(0, warnings.Count, "Task should have no warnings."); var error = errors [0]; Assert.AreEqual("keytool error: java.io.IOException: Keystore was tampered with, or password was incorrect", error.Message); Assert.AreEqual("ANDKT0000", error.Code); }
public void CheckSignaturesEqual() { Block block = this.network.Consensus.ConsensusFactory.CreateBlock(); var validationContext = new ValidationContext() { ChainedHeaderToValidate = this.currentHeader, BlockToValidate = block }; var ruleContext = new RuleContext(validationContext, DateTimeOffset.Now); var tool = new KeyTool(new DataFolder(string.Empty)); Key key1 = tool.GeneratePrivateKey(); Key key2 = tool.GeneratePrivateKey(); this.poaHeaderValidator.Sign(key1, this.currentHeader.Header as PoABlockHeader); this.poaHeaderValidator.Sign(key2, block.Header as PoABlockHeader); Assert.Throws <ConsensusErrorException>(() => this.integritySignatureRule.Run(ruleContext)); (block.Header as PoABlockHeader).BlockSignature = (this.currentHeader.Header as PoABlockHeader).BlockSignature; this.integritySignatureRule.Run(ruleContext); }
public virtual void Start() { LoadServiceNodes(); // TODO: what if load fails? Shouldn't we sync again if (this.ServiceNodes == null) { this.ServiceNodes = new List <IServiceNode>(); SaveServiceNodes(); } this.Logger.LogInformation("Network contains {0} service nodes. Their public keys are: {1}", this.ServiceNodes.Count, Environment.NewLine + string.Join(Environment.NewLine, this.ServiceNodes)); // Load key. Key key = new KeyTool(this.settings.DataFolder).LoadPrivateKey(); this.CurrentServiceNodeKey = key; SetIsServiceNode(); if (this.CurrentServiceNodeKey == null) { this.Logger.LogTrace("(-)[NOT_SERVICE_NODE]"); return; } // Loaded key has to be a key for current service node. if (this.ServiceNodes.All(x => x.EcdsaPubKey != this.CurrentServiceNodeKey.PubKey)) { string message = "Key provided is not registered on the network!"; this.Logger.LogWarning(message); } this.Logger.LogInformation("ServiceNode key pair was successfully loaded. Your public key is: '{0}'.", this.CurrentServiceNodeKey.PubKey); }
public void CreateDebugKeyStore() { string keyfile = Path.Combine(TestName, "debug.keystore"); if (File.Exists(keyfile)) { File.Delete(keyfile); } var task = new AndroidCreateDebugKey { BuildEngine = engine, KeyStore = keyfile, StorePass = "******", KeyAlias = "androiddebugkey", KeyPass = "******", KeyAlgorithm = "RSA", Validity = 10000, StoreType = "pkcs12", Command = "-genkeypair", ToolPath = keyToolPath, }; Assert.IsTrue(task.Execute(), "Task should have succeeded."); Assert.AreEqual(0, errors.Count, "Task should have no errors."); Assert.AreEqual(0, warnings.Count, "Task should have no warnings."); var keyToolTask = new KeyTool { BuildEngine = engine, KeyStore = keyfile, StorePass = "******", KeyAlias = "androiddebugkey", KeyPass = "******", Command = "-list", ToolPath = keyToolPath, }; Assert.IsTrue(keyToolTask.Execute(), "Task should have succeeded."); }
public async Task <IActionResult> RegisterAsync(RegisterServiceNodeRequest request) { try { var registration = new ServiceNodeRegistration(this.network, this.nodeSettings, this.broadcasterManager, this.walletTransactionHandler, this.walletManager, this.serviceNodeManager); Key key = new KeyTool(this.nodeSettings.DataFolder).LoadPrivateKey(); (KeyId collateralPubKeyHash, KeyId rewardPubKeyHash) = GetPubKeyHashes(this.serviceNodeSettings, request.WalletName, request.AccountName); var config = new ServiceNodeRegistrationConfig { ProtocolVersion = (int)ServiceNodeProtocolVersion.INITIAL, Ipv4Address = this.serviceNodeSettings.Ipv4Address ?? IPAddress.None, Ipv6Address = this.serviceNodeSettings.Ipv6Address ?? IPAddress.IPv6None, OnionAddress = null, Port = this.serviceNodeSettings.Port, PrivateKey = key, CollateralPubKeyHash = collateralPubKeyHash, RewardPubKeyHash = rewardPubKeyHash, TxFeeValue = this.serviceNodeSettings.TxFeeValue, TxOutputValue = this.serviceNodeSettings.TxOutputValue, ServiceEndpoint = this.serviceNodeSettings.ServiceEndpoint }; if (!registration.CheckExistingRegistration(config)) { this.logger.LogInformation("{Time} Creating or updating node registration", DateTime.Now); Transaction regTx = await registration.PerformRegistrationAsync(config, request.WalletName, request.Password, request.AccountName); if (regTx != null) { this.logger.LogInformation("{Time} Submitted node registration transaction {TxId} for broadcast", DateTime.Now, regTx.GetHash().ToString()); } else { this.logger.LogInformation("{Time} Unable to broadcast transaction", DateTime.Now); Environment.Exit(0); } return(Ok(new RegisterServiceNodeResponse { CollateralPubKeyHash = collateralPubKeyHash.ToString(), RewardPubKeyHash = rewardPubKeyHash.ToString(), RegistrationTxHash = regTx.GetHash().ToString() })); } else { logger.LogInformation("{Time} Node registration has already been performed", DateTime.Now); return(ErrorHelpers.BuildErrorResponse(HttpStatusCode.BadRequest, "Node registration failed", "Registration has already been performed successfully, you can't do it again.")); } } catch (Exception e) { Console.WriteLine(e); throw; } }