public override void ImportFromXml(IKeyStore keyStore, string xml, int keySize = 1024)
{
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize))
{
rsa.PersistKeyInCsp = false;
rsa.FromXmlString(xml);
keyStore.PublicKey.Key = rsa.ExportCspBlob(false);
if(!rsa.PublicOnly)
keyStore.PrivateKey.Key = rsa.ExportCspBlob(true);
}
}
public override void CreateNewKeyPair(IKeyStore keyStore, int keySize = 1024)
{
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize))
{
rsa.PersistKeyInCsp = false;
keyStore.PublicKey.Key = rsa.ExportCspBlob(false);
keyStore.PrivateKey.Key = rsa.ExportCspBlob(true);
keyStore.KeySize = keySize;
}
}
//we can't currently verify that the other set has more values than me, but that's ok for all current uses
public bool otherDictionaryIsEqualOrASuperset(IKeyStore other)
{
if(other == null) return false;
foreach(var kvp in store)
{
if(other.get(kvp.Key) != kvp.Value)
{
return false;
}
}
return true;
}
public override void ImportFromXml(IKeyStore keyStore, string xml, int keySize = 1024)
{
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize))
{
rsa.PersistKeyInCsp = false;
rsa.FromXmlString(xml);
keyStore.PublicKey.Key = rsa.ExportCspBlob(false);
if (!rsa.PublicOnly)
{
keyStore.PrivateKey.Key = rsa.ExportCspBlob(true);
}
}
}
public override void ImportFromBytes(IKeyStore keyStore, byte[] bytes, int keySize = 1024)
{
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize))
{
rsa.PersistKeyInCsp = false;
rsa.ImportCspBlob(bytes);
keyStore.PublicKey.Key = rsa.ExportCspBlob(false);
if (!rsa.PublicOnly)
{
keyStore.PrivateKey.Key = bytes;
}
}
}
public ProcessModule(IDatabaseContextFactory databaseContextFactory, IEventStore eventStore, IKeyStore keyStore,
IProcessConfiguration configuration)
{
Guard.AgainstNull(databaseContextFactory, "databaseContextFactory");
Guard.AgainstNull(eventStore, "eventStore");
Guard.AgainstNull(keyStore, "keyStore");
Guard.AgainstNull(configuration, "configuration");
_databaseContextFactory = databaseContextFactory;
_eventStore = eventStore;
_keyStore = keyStore;
_configuration = configuration;
}
public RegisterUserHandler(IConfiguredDatabaseContextFactory databaseContextFactory, IEventStore eventStore, IKeyStore keyStore, IHashingService hashingService)
{
Guard.AgainstNull(databaseContextFactory, "databaseContextFactory");
Guard.AgainstNull(eventStore, "eventStore");
Guard.AgainstNull(keyStore, "keyStore");
Guard.AgainstNull(hashingService, "hashingService");
_databaseContextFactory = databaseContextFactory;
_eventStore = eventStore;
_keyStore = keyStore;
_hashingService = hashingService;
_log = Log.For(this);
}
/// <summary>
/// Creates a new identity that can be used to sign transactions on the Loom DAppChain.
/// </summary>
/// <returns>A new <see cref="Identity"/>.</returns>
public async Task<Identity> CreateIdentityAsync(string accessToken, IKeyStore keyStore)
{
Logger.Log(LogTag, "Creating new account");
UserInfo profile = await this.auth0Client.GetUserInfoAsync(accessToken);
Logger.Log(LogTag, "Retrieved user profile");
var identity = new Identity
{
Username = profile.Email.Split('@')[0],
PrivateKey = CryptoUtils.GeneratePrivateKey()
};
// TODO: connect to blockchain & post a create an account Tx
await keyStore.SetAsync(identity.Username, identity.PrivateKey);
return identity;
}
public DefaultAuthenticationService(IConfiguredDatabaseContextFactory databaseContextFactory, IEventStore eventStore, IKeyStore keyStore, IHashingService hashingService)
{
Guard.AgainstNull(databaseContextFactory, "databaseContextFactory");
Guard.AgainstNull(eventStore, "eventStore");
Guard.AgainstNull(keyStore, "keyStore");
Guard.AgainstNull(hashingService, "hashingService");
_databaseContextFactory = databaseContextFactory;
_eventStore = eventStore;
_keyStore = keyStore;
_hashingService = hashingService;
_log = Log.For(this);
}
public FileManager(string _sKey, string _sEmailCadastradoNaChave)
{
this.sKey = _sKey;
this.sEmailCadastradoNaChave = _sEmailCadastradoNaChave;
GpgmeFileData keyfile = new GpgmeFileData(sKey);
keyStore = ctx.KeyStore;
ImportResult rst = keyStore.Import(keyfile);
keyring = ctx.KeyStore;
keys = keyring.GetKeyList(sEmailCadastradoNaChave, false);
keyfile.Close();
}
public override void ImportFromBytes(IKeyStore keyStore, byte[] bytes, int keySize = 1024)
{
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(keySize))
{
rsa.PersistKeyInCsp = false;
rsa.ImportCspBlob(bytes);
keyStore.PublicKey.Key = rsa.ExportCspBlob(false);
if (!rsa.PublicOnly)
keyStore.PrivateKey.Key = bytes;
}
}
//we can't currently verify that the other set has more values than me, but that's ok for all current uses
public bool otherDictionaryIsEqualOrASuperset(IKeyStore other)
{
if (other == null)
{
return(false);
}
foreach (var kvp in store)
{
if (other.get(kvp.Key) != kvp.Value)
{
return(false);
}
}
return(true);
}
public NodeKeyManager(
ICryptoRandom cryptoRandom,
IKeyStore keyStore,
IKeyStoreConfig config,
ILogManager logManager,
IPasswordProvider passwordProvider,
IFileSystem fileSystem)
{
_cryptoRandom = cryptoRandom ?? throw new ArgumentNullException(nameof(cryptoRandom));
_keyStore = keyStore ?? throw new ArgumentNullException(nameof(keyStore));
_config = config ?? throw new ArgumentNullException(nameof(config));
_logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
_passwordProvider = passwordProvider ?? throw new ArgumentNullException(nameof(passwordProvider));
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
}
public ProcessMessageHandlerInvoker(IDatabaseContextFactory databaseContextFactory, IEventStore eventStore,
IKeyStore keyStore,
IProcessConfiguration configuration)
{
Guard.AgainstNull(databaseContextFactory, "databaseContextFactory");
Guard.AgainstNull(eventStore, "eventStore");
Guard.AgainstNull(eventStore, "keyStore");
Guard.AgainstNull(configuration, "configuration");
_databaseContextFactory = databaseContextFactory;
_eventStore = eventStore;
_keyStore = keyStore;
_configuration = configuration;
_defaultMessageHandlerInvoker = new DefaultMessageHandlerInvoker();
}
public MessagesPageViewModel(
ApiClient apiClient,
CurrentUserManager currentUserManager,
IAsymetricEncryptionService asymetricEncryptionService,
ISymetricEnryptionService symetricEnryptionService,
IKeyStore keyStore)
{
this.apiClient = apiClient;
this.currentUserManager = currentUserManager;
this.asymetricEncryptionService = asymetricEncryptionService;
this.symetricEnryptionService = symetricEnryptionService;
this.keyStore = keyStore;
SendMessageCommand = ReactiveCommand.CreateFromTask(SendMessage);
Load();
}
/// <summary>
/// Creates a new identity that can be used to sign transactions on the Loom DAppChain.
/// </summary>
/// <returns>A new <see cref="Identity"/>.</returns>
public async Task <Identity> CreateIdentityAsync(string accessToken, IKeyStore keyStore)
{
taskAuthSource = new TaskCompletionSource <string> ();
_ex_callGetUserProfile("https://loomx.auth0.com" /*domain?*/, accessToken, onAuthResult);
await taskAuthSource.Task;
var profile = JsonConvert.DeserializeObject <ProfileUserInfo> (taskAuthSource.Task.Result);
var identity = new Identity {
Username = profile.Email.Split('@') [0],
PrivateKey = CryptoUtils.GeneratePrivateKey()
};
// TODO: connect to blockchain & post a create an account Tx
await keyStore.SetAsync(identity.Username, identity.PrivateKey);
return(identity);
}
public AuthenticationService(IAccessConfiguration configuration, IDatabaseContextFactory databaseContextFactory,
IEventStore eventStore, IKeyStore keyStore, IHashingService hashingService)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(databaseContextFactory, nameof(databaseContextFactory));
Guard.AgainstNull(eventStore, nameof(eventStore));
Guard.AgainstNull(keyStore, nameof(keyStore));
Guard.AgainstNull(hashingService, nameof(hashingService));
_configuration = configuration;
_databaseContextFactory = databaseContextFactory;
_eventStore = eventStore;
_keyStore = keyStore;
_hashingService = hashingService;
_log = Log.For(this);
}
private NodeKeyManagerTest CreateTest()
{
IKeyStore keyStore = Substitute.For <IKeyStore>();
ICryptoRandom cryptoRandom = Substitute.For <ICryptoRandom>();
KeyStoreConfig keyStoreConfig = new KeyStoreConfig();
IPasswordProvider passwordProvider = Substitute.For <IPasswordProvider>();
IFileSystem fileSystem = Substitute.For <IFileSystem>();
return(new NodeKeyManagerTest()
{
NodeKeyManager = new NodeKeyManager(cryptoRandom, keyStore, keyStoreConfig, LimboLogs.Instance, passwordProvider, fileSystem),
KeyStore = keyStore,
CryptoRandom = cryptoRandom,
KeyStoreConfig = keyStoreConfig,
PasswordProvider = passwordProvider,
FileSystem = fileSystem
});
}
public ParityModule(
IEcdsa ecdsa,
ITxPool txPool,
IBlockFinder blockFinder,
IReceiptFinder receiptFinder,
IEnode enode,
ISignerStore signerStore,
IKeyStore keyStore,
ILogManager logManager)
{
_ecdsa = ecdsa ?? throw new ArgumentNullException(nameof(ecdsa));
_txPool = txPool ?? throw new ArgumentNullException(nameof(txPool));
_blockFinder = blockFinder ?? throw new ArgumentNullException(nameof(blockFinder));
_receiptFinder = receiptFinder ?? throw new ArgumentNullException(nameof(receiptFinder));
_enode = enode ?? throw new ArgumentNullException(nameof(enode));
_signerStore = signerStore ?? throw new ArgumentNullException(nameof(signerStore));
_keyStore = keyStore ?? throw new ArgumentNullException(nameof(keyStore));
}
private void SetupKeyStore()
{
var encrypter = new AesEncrypter(
_configProvider.GetConfig <IKeyStoreConfig>(),
_logManager);
_keyStore = new FileKeyStore(
_configProvider.GetConfig <IKeyStoreConfig>(),
_ethereumJsonSerializer,
encrypter,
_cryptoRandom,
_logManager);
switch (_initConfig)
{
case var _ when HiveEnabled:
// todo: use the keystore wallet here
_wallet = new HiveWallet();
break;
case var config when config.EnableUnsecuredDevWallet && config.KeepDevWalletInMemory:
_wallet = new DevWallet(_configProvider.GetConfig <IWalletConfig>(), _logManager);
break;
case var config when config.EnableUnsecuredDevWallet && !config.KeepDevWalletInMemory:
_wallet = new DevKeyStoreWallet(_keyStore, _logManager);
break;
default:
_wallet = new NullWallet();
break;
}
INodeKeyManager nodeKeyManager = new NodeKeyManager(_cryptoRandom, _keyStore, _configProvider.GetConfig <IKeyStoreConfig>(), _logManager);
_nodeKey = nodeKeyManager.LoadNodeKey();
var ipVariable = Environment.GetEnvironmentVariable("NETHERMIND_ENODE_IPADDRESS");
var localIp = string.IsNullOrWhiteSpace(ipVariable)
? _networkHelper.GetLocalIp()
: IPAddress.Parse(ipVariable);
_enode = new Enode(_nodeKey.PublicKey, localIp, _initConfig.P2PPort);
}
public NdmRequiredServices(IConfigProvider configProvider, IConfigManager configManager, INdmConfig ndmConfig,
string baseDbPath, IDbProvider rocksProvider, IMongoProvider mongoProvider, ILogManager logManager,
IBlockTree blockTree, ITxPool transactionPool, ISpecProvider specProvider, IReceiptStorage receiptStorage,
IFilterStore filterStore, IFilterManager filterManager, IWallet wallet, ITimestamper timestamper,
IEthereumEcdsa ecdsa, IKeyStore keyStore, IRpcModuleProvider rpcModuleProvider,
IJsonSerializer jsonSerializer, ICryptoRandom cryptoRandom, IEnode enode,
INdmConsumerChannelManager ndmConsumerChannelManager, INdmDataPublisher ndmDataPublisher,
IGrpcServer grpcServer, IEthRequestService ethRequestService, INdmNotifier notifier,
bool enableUnsecuredDevWallet, IBlockProcessor blockProcessor, IJsonRpcClientProxy jsonRpcClientProxy,
IEthJsonRpcClientProxy ethJsonRpcClientProxy, IHttpClient httpClient, IMonitoringService monitoringService)
{
ConfigProvider = configProvider;
ConfigManager = configManager;
NdmConfig = ndmConfig;
BaseDbPath = baseDbPath;
RocksProvider = rocksProvider;
MongoProvider = mongoProvider;
LogManager = logManager;
BlockTree = blockTree;
TransactionPool = transactionPool;
SpecProvider = specProvider;
ReceiptStorage = receiptStorage;
FilterStore = filterStore;
FilterManager = filterManager;
Wallet = wallet;
Timestamper = timestamper;
Ecdsa = ecdsa;
KeyStore = keyStore;
RpcModuleProvider = rpcModuleProvider;
JsonSerializer = jsonSerializer;
CryptoRandom = cryptoRandom;
Enode = enode;
NdmConsumerChannelManager = ndmConsumerChannelManager;
NdmDataPublisher = ndmDataPublisher;
GrpcServer = grpcServer;
EthRequestService = ethRequestService;
Notifier = notifier;
EnableUnsecuredDevWallet = enableUnsecuredDevWallet;
BlockProcessor = blockProcessor;
JsonRpcClientProxy = jsonRpcClientProxy;
EthJsonRpcClientProxy = ethJsonRpcClientProxy;
HttpClient = httpClient;
MonitoringService = monitoringService;
}
public void Setup()
{
_ndmModule = Substitute.For <INdmModule>();
_ndmConsumersModule = Substitute.For <INdmConsumersModule>();
_configProvider = Substitute.For <IConfigProvider>();
_dbProvider = Substitute.For <IDbProvider>();
_blockTree = Substitute.For <IBlockTree>();
_txPool = Substitute.For <ITxPool>();
_txSender = Substitute.For <ITxSender>();
_specProvider = Substitute.For <ISpecProvider>();
_receiptFinder = Substitute.For <IReceiptFinder>();
_wallet = Substitute.For <IWallet>();
_filterStore = Substitute.For <IFilterStore>();
_filterManager = Substitute.For <IFilterManager>();
_timestamper = Substitute.For <ITimestamper>();
_ecdsa = Substitute.For <IEthereumEcdsa>();
_rpcModuleProvider = Substitute.For <IRpcModuleProvider>();
_keyStore = Substitute.For <IKeyStore>();
_jsonSerializer = Substitute.For <IJsonSerializer>();
_cryptoRandom = Substitute.For <ICryptoRandom>();
_enode = Substitute.For <IEnode>();
_consumerChannelManager = Substitute.For <INdmConsumerChannelManager>();
_dataPublisher = Substitute.For <INdmDataPublisher>();
_grpcServer = Substitute.For <IGrpcServer>();
_nodeStatsManager = Substitute.For <INodeStatsManager>();
_protocolsManager = Substitute.For <IProtocolsManager>();
_protocolValidator = Substitute.For <IProtocolValidator>();
_messageSerializationService = Substitute.For <IMessageSerializationService>();
_webSocketsManager = Substitute.For <IWebSocketsManager>();
_logManager = LimboLogs.Instance;
_blockProcessor = Substitute.For <IBlockProcessor>();
_jsonRpcClientProxy = Substitute.For <IJsonRpcClientProxy>();
_ethJsonRpcClientProxy = Substitute.For <IEthJsonRpcClientProxy>();
_httpClient = Substitute.For <IHttpClient>();
_monitoringService = Substitute.For <IMonitoringService>();
_enableUnsecuredDevWallet = false;
_ndmConfig = new NdmConfig {
Enabled = true, StoreConfigInDatabase = false
};
_configProvider.GetConfig <INdmConfig>().Returns(_ndmConfig);
_ndmInitializer = new NdmInitializer(_ndmModule, _ndmConsumersModule, _logManager);
_bloomStorage = Substitute.For <IBloomStorage>();
}
public void Initialize()
{
_config = new KeyStoreConfig();
_keyStoreDir = _config.KeyStoreDirectory;
if (!Directory.Exists(_keyStoreDir))
{
Directory.CreateDirectory(_keyStoreDir);
}
ILogManager logManager = NullLogManager.Instance;
_serializer = new EthereumJsonSerializer();
_cryptoRandom = new CryptoRandom();
_store = new FileKeyStore(_config, _serializer, new AesEncrypter(_config, logManager), _cryptoRandom, logManager);
var testsContent = File.ReadAllText("basic_tests.json");
_testsModel = _serializer.Deserialize <KeyStoreTestsModel>(testsContent);
}
public async Task<Identity> GetIdentityAsync(string accessToken, IKeyStore keyStore)
{
var keys = await keyStore.GetKeysAsync();
if (keys.Length > 0)
{
// existing account
var parts = keys[0].Split('/'); // TODO: This doesn't really do much atm
var privateKey = await keyStore.GetPrivateKeyAsync(keys[0]);
return new Identity
{
Username = parts[parts.Length - 1],
PrivateKey = privateKey
};
}
else
{
return await CreateIdentityAsync(accessToken, keyStore);
}
}
public DevKeyStoreWallet(IKeyStore keyStore, ILogManager logManager)
{
_keyStore = keyStore;
_logger = logManager.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager));
KeySeed[31] = 1;
for (int i = 0; i < 3; i++)
{
PrivateKey key = new PrivateKey(KeySeed);
if (GetAccounts().All(a => a != key.Address))
{
SecureString secureString = new SecureString();
secureString.MakeReadOnly();
_keyStore.StoreKey(key, secureString);
}
_unlockedAccounts.Add(key.Address, key);
KeySeed[31]++;
}
}
public async Task <Identity> GetIdentityAsync(string accessToken, IKeyStore keyStore)
{
if (this.HostPageHandlers == null || string.IsNullOrEmpty(this.HostPageHandlers.GetUserInfo))
{
throw new Exception("GetUserInfo handler not set.");
}
var userInfo = JsonConvert.DeserializeObject <UserInfo>(GetLoomUserInfo(this.HostPageHandlers.GetUserInfo));
if (string.IsNullOrEmpty(userInfo.Username) || string.IsNullOrEmpty(userInfo.PrivateKey))
{
if (this.HostPageHandlers == null || string.IsNullOrEmpty(this.HostPageHandlers.SignIn))
{
throw new Exception("SignIn handler not set.");
}
StartLoomAuthFlow(this.HostPageHandlers.SignIn);
var startTime = Time.time;
var isTimedOut = false;
// poll local storage until the user info shows up
while (!isTimedOut)
{
await new WaitForSecondsRealtime(0.5f);
userInfo = JsonConvert.DeserializeObject <UserInfo>(GetLoomUserInfo(this.HostPageHandlers.GetUserInfo));
if (!string.IsNullOrEmpty(userInfo.Username) && !string.IsNullOrEmpty(userInfo.PrivateKey))
{
break;
}
// keep trying for about 60 secs (though probably should make this configurable)
isTimedOut = (Time.time - startTime) > 60.0f;
}
if (isTimedOut)
{
throw new Exception("User is not signed in.");
}
}
var privateKey = CryptoUtils.HexStringToBytes(userInfo.PrivateKey);
return(await Task.FromResult(new Identity
{
Username = userInfo.Username,
PrivateKey = privateKey
}));
}
static void Main(string[] args)
{
IAddressTransaction txn5 = SetupTransactions();
//Only needed if we want it to be a private blockchain
//IKeyStore keyStore = new KeyStore(Hmac.GenerateKey());
IKeyStore keyStore = null;
IBlock <IAddressTransaction> block1 = new Block(0, keyStore, 3);
IBlock <IAddressTransaction> block2 = new Block(1, keyStore, 3);
IBlock <IAddressTransaction> block3 = new Block(2, keyStore, 3);
IBlock <IAddressTransaction> block4 = new Block(3, keyStore, 3);
AddTransactionsToBlocksAndCalculateHashes(block1, block2, block3, block4);
BlockChain chain = new BlockChain();
chain.AcceptBlock(block1);
chain.AcceptBlock(block2);
chain.AcceptBlock(block3);
chain.AcceptBlock(block4);
chain.VerifyChain();
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("=========================");
Console.WriteLine($"{pubAddress1}' balance: {chain.GetBalance(pubAddress1)}");
((IClaimOutput)txn5.Outputs[0]).ClaimNumber = "weqwewe";
chain.VerifyChain();
Console.WriteLine();
Console.WriteLine("=========================");
Console.WriteLine($"Chain");
Console.WriteLine(JsonConvert.SerializeObject(chain, Formatting.Indented));
Console.ReadKey();
}
public void Initialize()
{
_configurationProvider = new JsonConfigProvider();
_keyStoreDir = _configurationProvider.GetConfig <KeystoreConfig>().KeyStoreDirectory;
if (!Directory.Exists(_keyStoreDir))
{
Directory.CreateDirectory(_keyStoreDir);
}
ILogManager logManager = NullLogManager.Instance;
_serializer = new JsonSerializer(logManager);
_cryptoRandom = new CryptoRandom();
_store = new FileKeyStore(_configurationProvider, _serializer, new AesEncrypter(_configurationProvider, logManager), _cryptoRandom, logManager);
var testsContent = File.ReadAllText("basic_tests.json");
_testsModel = _serializer.Deserialize <KeyStoreTestsModel>(testsContent);
_testAddress = new PrivateKey(_cryptoRandom.GenerateRandomBytes(32)).Address;
}
public VerifiedSignature Signature(IRequest r, ISignatureSpecification spec, IKeyStore keyStore)
{
var authorization = r.GetHeader("authorization");
if (string.IsNullOrEmpty(authorization)) throw new SignatureMissingException("No authorization header present");
var signatureAuth = authorizationParser.Parse(authorization);
if (spec == null) {
spec = signatureAuth;
} else {
if (spec.Algorithm != signatureAuth.Algorithm) {
throw new InvalidSignatureException(string.Format("Algorith mismatch. Wanted: {0}, found: {1}", spec.Algorithm, signatureAuth.Algorithm));
}
var missingHeaders = spec.Headers.Where(h=> !signatureAuth.Headers.Contains(h)).ToList();
if (missingHeaders.Any()) {
throw new InvalidSignatureException(string.Format("Missing headers in signature: {0}", string.Join(",", missingHeaders)));
}
}
var signature = CalculateSignature(r, spec, keyStore.Get(signatureAuth.KeyId));
return new VerifiedSignature(signatureAuth, signature);
}
public static async Task RSASignedCrlCreateWith2Test(SignatureType signature)
{
using (var mock = AutoMock.GetLoose()) {
Setup(mock);
IKeyStore keys = mock.Create <KeyDatabase>();
ICrlFactory factory = mock.Create <CrlFactory>();
using (var root = SignatureType.PS512.Create("CN=root", true))
using (var ca1 = root.Create(SignatureType.PS256, "CN=ca1", true))
using (var ca2 = root.Create(SignatureType.PS256, "CN=ca2", true))
using (var leaf1 = ca1.Create(SignatureType.RS256, "CN=leaf1"))
using (var leaf2 = ca1.Create(SignatureType.RS256, "CN=leaf2"))
using (var leaf3 = ca1.Create(SignatureType.RS256, "CN=leaf3")) {
var rootPrivateKey = root.ExportPrivateKey();
var rootPublicKey = rootPrivateKey.GetPublicKey();
var rootKeyHandle = await keys.ImportKeyAsync("ababa", rootPrivateKey,
new KeyStoreProperties { Exportable = true });
var next = DateTime.UtcNow + TimeSpan.FromDays(4);
next = next.Date;
var rootCert = root.ToCertificate(new IssuerPolicies(), rootKeyHandle);
var crl = await factory.CreateCrlAsync(rootCert, signature,
new List <Certificate> {
ca2.ToCertificate(),
ca1.ToCertificate()
}, next);
var privateKey = await keys.ExportKeyAsync(rootKeyHandle);
Assert.True(rootPrivateKey.SameAs(privateKey));
Assert.Equal(next, crl.NextUpdate);
Assert.Equal(root.Subject, crl.Issuer);
Assert.True(crl.IsRevoked(ca1.ToCertificate()));
Assert.True(crl.IsRevoked(ca2.ToCertificate()));
Assert.True(crl.HasValidSignature(rootCert));
}
}
}
public void Initialize()
{
_testPasswordSecured = new SecureString();
_wrongPasswordSecured = new SecureString();
for (int i = 0; i < _testPassword.Length; i++)
{
_testPasswordSecured.AppendChar(_testPassword[i]);
_wrongPasswordSecured.AppendChar('*');
}
_testPasswordSecured.MakeReadOnly();
_wrongPasswordSecured.MakeReadOnly();
_configurationProvider = new JsonConfigProvider();
ILogManager logger = NullLogManager.Instance;
_serializer = new JsonSerializer(logger);
_cryptoRandom = new CryptoRandom();
_store = new FileKeyStore(_configurationProvider, _serializer, new AesEncrypter(_configurationProvider, logger), _cryptoRandom, logger);
}
private async Task RevokeKey <T>(IKeyStore <T> keyStore, string id, string reason)
{
try
{
await keyStore.RevokeKeyAsync(id, reason).ConfigureAwait(false);
await _notifier.NotifyAsync(new Notification
{
Header = id,
Message = Localizer["Revoked"]
}).ConfigureAwait(false);
}
catch
{
await _notifier.NotifyAsync(new Notification
{
Header = id,
IsError = true,
Message = Localizer["Error when trying to revoke the key."]
}).ConfigureAwait(false);
}
}
private void SetupKeyStore()
{
var encrypter = new AesEncrypter(
_configProvider.GetConfig <IKeyStoreConfig>(),
_logManager);
_keyStore = new FileKeyStore(
_configProvider.GetConfig <IKeyStoreConfig>(),
_ethereumJsonSerializer,
encrypter,
_cryptoRandom,
_logManager);
switch (_initConfig)
{
case var _ when HiveEnabled:
// todo: use the keystore wallet here
_wallet = new HiveWallet();
break;
case var config when config.EnableUnsecuredDevWallet && config.KeepDevWalletInMemory:
_wallet = new DevWallet(_configProvider.GetConfig <IWalletConfig>(), _logManager);
break;
case var config when config.EnableUnsecuredDevWallet && !config.KeepDevWalletInMemory:
_wallet = new DevKeyStoreWallet(_keyStore, _logManager);
break;
default:
_wallet = new NullWallet();
break;
}
INodeKeyManager nodeKeyManager = new NodeKeyManager(_cryptoRandom, _keyStore, _configProvider.GetConfig <IKeyStoreConfig>(), _logManager);
_nodeKey = nodeKeyManager.LoadNodeKey();
_enode = new Enode(_nodeKey.PublicKey, IPAddress.Parse(_networkConfig.ExternalIp), _networkConfig.P2PPort);
}
public void Setup()
{
_configProvider = Substitute.For <IConfigProvider>();
_configManager = Substitute.For <IConfigManager>();
_ndmConfig = new NdmConfig();
_baseDbPath = "db";
_rocksProvider = Substitute.For <IDbProvider>();
_mongoProvider = Substitute.For <IMongoProvider>();
_logManager = LimboLogs.Instance;
_blockTree = Substitute.For <IBlockTree>();
_specProvider = Substitute.For <ISpecProvider>();
_transactionPool = Substitute.For <ITxPool>();
_txSender = Substitute.For <ITxSender>();
_receiptStorage = Substitute.For <IReceiptStorage>();
_filterStore = Substitute.For <IFilterStore>();
_filterManager = Substitute.For <IFilterManager>();
_wallet = Substitute.For <IWallet>();
_timestamper = Substitute.For <ITimestamper>();
_ecdsa = Substitute.For <IEthereumEcdsa>();
_keyStore = Substitute.For <IKeyStore>();
_rpcModuleProvider = Substitute.For <IRpcModuleProvider>();
_jsonSerializer = Substitute.For <IJsonSerializer>();
_cryptoRandom = Substitute.For <ICryptoRandom>();
_enode = Substitute.For <IEnode>();
_ndmConsumerChannelManager = Substitute.For <INdmConsumerChannelManager>();
_ndmDataPublisher = Substitute.For <INdmDataPublisher>();
_grpcServer = Substitute.For <IGrpcServer>();
_ethRequestService = Substitute.For <IEthRequestService>();
_notifier = Substitute.For <INdmNotifier>();
_enableUnsecuredDevWallet = false;
_blockProcessor = Substitute.For <IBlockProcessor>();
_jsonRpcClientProxy = Substitute.For <IJsonRpcClientProxy>();
_ethJsonRpcClientProxy = Substitute.For <IEthJsonRpcClientProxy>();
_httpClient = Substitute.For <IHttpClient>();
_monitoringService = Substitute.For <IMonitoringService>();
_ndmModule = new NdmModule();
_bloomStorage = Substitute.For <IBloomStorage>();
}
PreInitAsync(
IConfigProvider configProvider,
IDbProvider dbProvider,
string baseDbPath,
IBlockTree blockTree,
ITxPool txPool,
ITxSender txSender,
ISpecProvider specProvider,
IReceiptFinder receiptFinder,
IWallet wallet,
IFilterStore filterStore,
IFilterManager filterManager,
ITimestamper timestamper,
IEthereumEcdsa ecdsa,
IRpcModuleProvider rpcModuleProvider,
IKeyStore keyStore,
IJsonSerializer jsonSerializer,
ICryptoRandom cryptoRandom,
IEnode enode,
INdmConsumerChannelManager consumerChannelManager,
INdmDataPublisher dataPublisher,
IGrpcServer grpcServer,
bool enableUnsecuredDevWallet,
IWebSocketsManager webSocketsManager,
ILogManager logManager,
IBlockProcessor blockProcessor,
IJsonRpcClientProxy?jsonRpcClientProxy,
IEthJsonRpcClientProxy?ethJsonRpcClientProxy,
IHttpClient httpClient,
IMonitoringService monitoringService,
IBloomStorage bloomStorage)
{
// what is block processor doing here?
if (!(configProvider.GetConfig <INdmConfig>() is NdmConfig defaultConfig))
{
return(default);
public RequiredServices(IConfigProvider configProvider, IConfigManager configManager, INdmConfig ndmConfig,
string baseDbPath, IDbProvider rocksProvider, IMongoProvider mongoProvider, ILogManager logManager,
IBlockProcessor blockProcessor, IBlockTree blockTree, ITxPool transactionPool,
ITxPoolInfoProvider transactionPoolInfoProvider, ISpecProvider specProvider,
IReceiptStorage receiptStorage, IWallet wallet, ITimestamp timestamp, IEthereumEcdsa ecdsa,
IKeyStore keyStore, IRpcModuleProvider rpcModuleProvider, IJsonSerializer jsonSerializer,
ICryptoRandom cryptoRandom, IEnode enode, INdmConsumerChannelManager ndmConsumerChannelManager,
INdmDataPublisher ndmDataPublisher, IGrpcService grpcService, EthRequestService ethRequestService,
bool enableUnsecuredDevWallet)
{
ConfigProvider = configProvider;
ConfigManager = configManager;
NdmConfig = ndmConfig;
BaseDbPath = baseDbPath;
RocksProvider = rocksProvider;
MongoProvider = mongoProvider;
LogManager = logManager;
BlockProcessor = blockProcessor;
BlockTree = blockTree;
TransactionPool = transactionPool;
TransactionPoolInfoProvider = transactionPoolInfoProvider;
SpecProvider = specProvider;
ReceiptStorage = receiptStorage;
Wallet = wallet;
Timestamp = timestamp;
Ecdsa = ecdsa;
KeyStore = keyStore;
RpcModuleProvider = rpcModuleProvider;
JsonSerializer = jsonSerializer;
CryptoRandom = cryptoRandom;
Enode = enode;
NdmConsumerChannelManager = ndmConsumerChannelManager;
NdmDataPublisher = ndmDataPublisher;
GrpcService = grpcService;
EthRequestService = ethRequestService;
EnableUnsecuredDevWallet = enableUnsecuredDevWallet;
}
static async Task Main(string[] args)
{
Rlp.RegisterDecoders(typeof(DepositDecoder).Assembly);
Rlp.RegisterDecoders(typeof(DepositDetailsDecoder).Assembly);
string dbPath = args[0];
ConsoleAsyncLogger asyncLogger = new ConsoleAsyncLogger(LogLevel.Info);
OneLoggerLogManager logManager = new OneLoggerLogManager(asyncLogger);
var deposits = await LoadDeposits(logManager, dbPath);
IKeyStore keyStore = BuildKeyStore(logManager);
DevKeyStoreWallet wallet = new DevKeyStoreWallet(keyStore, logManager, false);
foreach (var depositGroup in deposits.Items.GroupBy(d => d.Consumer))
{
Console.WriteLine($"Deposits by {depositGroup.Key}");
foreach (DepositDetails depositDetails in depositGroup)
{
DateTimeOffset dto = DateTimeOffset.FromUnixTimeSeconds(depositDetails.Deposit.ExpiryTime);
Console.WriteLine($" [REFUNDABLE] Deposit by {depositDetails.Consumer} for {depositDetails.DataAsset.Name} {depositDetails.Deposit.Units} expired on {dto.Date:f}");
}
Transaction[] refundTxs = GenerateTxsForRefunds(depositGroup, wallet);
foreach (Transaction transaction in refundTxs)
{
Console.WriteLine();
Console.WriteLine("***************************************");
TxDecoder decoder = new TxDecoder();
Rlp txRlp = decoder.Encode(transaction);
Console.WriteLine(txRlp.Bytes.ToHexString());
Console.WriteLine("***************************************");
}
}
Console.ReadLine();
}
public virtual void ImportFromXml(IKeyStore keyStore, string xml, int keySize = 1024)
{
}
private void standardCheck(IKeyStore store, Dictionary<string, string> keyValueMap)
{
foreach(var kvp in keyValueMap)
{
store.set(kvp.Key, kvp.Value);
}
//make sure that it wasn't just giving you the last result put in by iterating over the entire dictionary again
foreach(var kvp in keyValueMap)
{
Assert.AreEqual(store.get(kvp.Key), keyValueMap[kvp.Key]);
}
}
public SignatureAuthenticator(ISignatureSpecification signatureSpec, IKeyStore keyStore)
{
_signatureSpec = signatureSpec;
_keyStore = keyStore;
_log = LogManager.GetCurrentClassLogger();
}
public virtual void CreateNewKeyPair(IKeyStore keyStore, int keySize = 1024) { }
public VerifiedSignature Signature(HttpRequest r, ISignatureSpecification spec, IKeyStore keyStore)
{
return Signature(Request.FromHttpRequest(r), spec, keyStore);
}
public virtual void ImportFromBytes(IKeyStore keyStore, byte[] bytes, int keySize = 1024)
{
}
public override void EnableEncryption(IKeyStore keyStore)
{
if (HubPublicKey == null) throw new Exception("Hub public key not set, cannot enable encryption!");
base.EnableEncryption(keyStore);
}
/// <summary>
/// Gets a Security Session.
/// </summary>
/// <param name="securitySessionName">The name of the Security Session.</param>
/// <param name="keyStore">The store of all keys.</param>
/// <returns>An object implementing ISecuritySession interface.</returns>
public SecuritySession GetSecuritySession(string securitySessionName, IKeyStore keyStore)
{
lock (this.DisposeLock)
{
if (this.IsDisposed)
throw OperationException.WrapException(this.DisposeReason);
lock(_securitySessions)
{
SecuritySession iSecuritySession = _securitySessions[securitySessionName] as SecuritySession;
if (iSecuritySession == null)
{
IKeyProvider iKeyProvider = keyStore.GetKey(securitySessionName);
if (iKeyProvider == null)
throw GenuineExceptions.Get_Security_ContextNotFound(securitySessionName);
iSecuritySession = iKeyProvider.CreateSecuritySession(securitySessionName, this);
_securitySessions[securitySessionName] = iSecuritySession;
}
return iSecuritySession;
}
}
}
public virtual void EnableEncryption(IKeyStore keyStore)
{
KeyStore = keyStore;
KeyStore.Load();
// TODO: Fix hard coded encryption -NM 2016-11-24
KeyEncryption = new RSA();
MessageEncryption = new Rijndael();
}
public static VerifiedSignature VerifiedSignature(HttpRequest request, ISignatureSpecification spec, IKeyStore keyStore)
{
return Signer.Signature(request, spec, keyStore);
}
