public void Initialize()
{
NetworkNodeDecoder.Init();
var privateKey = new PrivateKey(TestPrivateKeyHex);
_publicKey = privateKey.PublicKey;
var logManager = NullLogManager.Instance;
IKeyStoreConfig keyStoreConfig = new KeyStoreConfig();
INetworkConfig networkConfig = new NetworkConfig();
networkConfig.PongTimeout = 100;
IStatsConfig statsConfig = new StatsConfig();
_messageSender = Substitute.For <IMessageSender>();
var calculator = new NodeDistanceCalculator(networkConfig);
_nodeTable = new NodeTable(new FileKeyStore(keyStoreConfig, new EthereumJsonSerializer(), new AesEncrypter(keyStoreConfig, logManager), new CryptoRandom(), logManager), calculator, networkConfig, logManager);
_nodeTable.Initialize(TestItem.PublicKeyA);
_timestamp = new Timestamp();
var evictionManager = new EvictionManager(_nodeTable, logManager);
var lifecycleFactory = new NodeLifecycleManagerFactory(_nodeTable, new DiscoveryMessageFactory(networkConfig, _timestamp), evictionManager, new NodeStatsManager(statsConfig, logManager), networkConfig, logManager);
_nodes = new[] { new Node("192.168.1.18", 1), new Node("192.168.1.19", 2) };
_discoveryManager = new DiscoveryManager(lifecycleFactory, _nodeTable, new NetworkStorage("test", networkConfig, logManager, new PerfService(logManager)), networkConfig, logManager);
_discoveryManager.MessageSender = _messageSender;
}
public void Initialize()
{
var keystoreConfig = new KeyStoreConfig();
var networkConfig = new NetworkConfig();
var jsonRpcConfig = new JsonRpcConfig();
var statsConfig = new StatsConfig();
}
private static IKeyStoreClient SetupKeyStoreHttpClient(KeyStoreConfig config)
{
return(new KeyStoreClient
{
BaseUri = new Uri(config.Url)
});
}
private IWallet SetupWallet(WalletType walletType)
{
switch (walletType)
{
case WalletType.KeyStore:
{
IKeyStoreConfig config = new KeyStoreConfig();
config.KeyStoreDirectory = _keyStorePath;
ISymmetricEncrypter encrypter = new AesEncrypter(config, LimboLogs.Instance);
return(new DevKeyStoreWallet(
new FileKeyStore(config, new EthereumJsonSerializer(), encrypter, new CryptoRandom(), LimboLogs.Instance),
LimboLogs.Instance));
}
case WalletType.Memory:
return(new DevWallet(new WalletConfig(), LimboLogs.Instance));
case WalletType.ProtectedKeyStore:
{
IKeyStoreConfig config = new KeyStoreConfig();
config.KeyStoreDirectory = _keyStorePath;
ISymmetricEncrypter encrypter = new AesEncrypter(config, LimboLogs.Instance);
var wallet = new ProtectedKeyStoreWallet(
new FileKeyStore(config, new EthereumJsonSerializer(), encrypter, new CryptoRandom(), LimboLogs.Instance),
new ProtectedPrivateKeyFactory(new CryptoRandom(), Timestamper.Default),
Timestamper.Default,
LimboLogs.Instance);
wallet.SetupTestAccounts(3);
return(wallet);
}
default:
throw new ArgumentOutOfRangeException(nameof(walletType), walletType, null);
}
}
public void Initialize()
{
var keystoreConfig = new KeyStoreConfig();
var networkConfig = new NetworkConfig();
var jsonRpcConfig = new JsonRpcConfig();
var statsConfig = new StatsConfig();
_configProvider = new JsonConfigProvider("SampleJsonConfig.cfg");
}
private static IKeyStore BuildKeyStore(OneLoggerLogManager logManager)
{
KeyStoreConfig keyStoreConfig = new KeyStoreConfig();
keyStoreConfig.KeyStoreDirectory = Path.GetDirectoryName(typeof(Program).Assembly.Location);
return(new FileKeyStore(
keyStoreConfig,
new EthereumJsonSerializer(),
new AesEncrypter(keyStoreConfig, logManager),
new CryptoRandom(),
logManager));
}
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
});
}
private IWallet SetupWallet(DevWalletType devWalletType)
{
switch (devWalletType)
{
case DevWalletType.KeyStore:
IKeyStoreConfig config = new KeyStoreConfig();
config.KeyStoreDirectory = _keyStorePath;
ISymmetricEncrypter encrypter = new AesEncrypter(config, LimboLogs.Instance);
return(new DevKeyStoreWallet(
new FileKeyStore(config, new EthereumJsonSerializer(), encrypter, new CryptoRandom(), LimboLogs.Instance),
LimboLogs.Instance));
case DevWalletType.Memory:
return(new DevWallet(new WalletConfig(), LimboLogs.Instance));
default:
throw new ArgumentOutOfRangeException(nameof(devWalletType), devWalletType, null);
}
}
public TestContext()
{
KeyStoreConfig = new KeyStoreConfig();
KeyStoreConfig.KeyStoreDirectory = NUnit.Framework.TestContext.CurrentContext.WorkDirectory;
TestPasswordSecured = new SecureString();
WrongPasswordSecured = new SecureString();
for (int i = 0; i < TestPassword.Length; i++)
{
TestPasswordSecured.AppendChar(TestPassword[i]);
WrongPasswordSecured.AppendChar('*');
}
TestPasswordSecured.MakeReadOnly();
WrongPasswordSecured.MakeReadOnly();
ILogManager logger = LimboLogs.Instance;
Serializer = new EthereumJsonSerializer();
CryptoRandom = new CryptoRandom();
Store = new FileKeyStore(KeyStoreConfig, Serializer, new AesEncrypter(KeyStoreConfig, logger), CryptoRandom, logger, new PrivateKeyStoreIOSettingsProvider(KeyStoreConfig));
}
private static TokenValidationParameters CreateTokenValidationParameters(ISignatureKeyResolver keyResolver, KeyStoreConfig keyStoreConfig)
{
if (keyStoreConfig.Bypass)
{
Log.Fatal("!!!!!! Bypassing security signature, THIS CANNOT RUN ON PRODUCTION");
// This allows us to reproduce production scenarios and step into the code using a legit JWT without
// exposing the key service publicly
return(new TokenValidationParameters
{
ValidateIssuer = false,
ValidIssuer = "GenericCompany",
ValidateAudience = false,
ValidAudiences = new [] { "GenericCompany" },
ValidateIssuerSigningKey = false,
SignatureValidator = (token, parameters) => new JwtSecurityToken(token),
RequireExpirationTime = true,
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero,
RequireSignedTokens = false
});
}
return(new TokenValidationParameters
{
ValidateIssuer = true,
ValidateIssuerSigningKey = true,
ValidateLifetime = true,
ValidateActor = true,
ValidateAudience = true,
ValidIssuer = "GenericCompany",
ValidAudiences = new[] { "GenericCompany" },
ClockSkew = TimeSpan.Zero,
IssuerSigningKeyResolver = (token, securityToken, kid, parameters) =>
{
// todo: I know this .Result is a very bad idea (converting from async to sync)
// however there's no other way to do this, signing key resolver doesn't have a
// async version of this method, they are looking into it though
// https://github.com/AzureAD/azure-activedirectory-identitymodel-extensions-for-dotnet/issues/468
var key = keyResolver.ResolveKey(kid).Result;
var pemReader = new PemReader(new MemoryStream(Encoding.UTF8.GetBytes(key)));
var publicKeyParameters = pemReader.ReadRsaKey();
return new[] { new RsaSecurityKey(publicKeyParameters) };
}
});
}
public async Task <byte[]> GenerateCertificateWithNewKeyPairAndGetKeyStoreAsync(string realm, string clientId, string attribute, KeyStoreConfig keyStoreConfig) => await GetBaseUrl(realm)
.AppendPathSegment($"/admin/realms/{realm}/clients/{clientId}/certificates/{attribute}/generate-and-download")
.PostJsonAsync(keyStoreConfig)
.ReceiveBytes()
.ConfigureAwait(false);
