static void Main(string[] args)
{
Console.WriteLine(2 << 1);
Console.WriteLine(RsaKeyGenerator.XmlKey(2048)[0]);
Console.WriteLine(RsaKeyGenerator.Pkcs1Key(2048, true)[0]);
Console.WriteLine(RsaKeyGenerator.Pkcs8Key(2048, true)[0]);
Console.WriteLine("Key Convert:");
var keyList = RsaKeyGenerator.Pkcs1Key(512, false);
var privateKey = keyList[0];
var publicKey = keyList[1];
Console.WriteLine("public key pkcs1->xml:");
Console.WriteLine(RsaKeyConvert.PublicKeyPemToXml(publicKey));
var bigDataRsa = new RsaPkcs1Util(Encoding.UTF8, publicKey, privateKey, 2048);
var data = "响应式布局的概念是一个页面适配多个终端及不同分辨率。在针对特定屏幕宽度优化应用 UI 时，我们将此称为创建响应式设计。WPF设计之初响应式设计的概念并不流行，那时候大部分网页设计师都按着宽度960像素的标准设计。到了UWP诞生的时候响应式布局已经很流行了，所以UWP提供了很多响应式布局的技术，这篇文章简单总结了一些响应式布局常用的技术，更完整的内容请看文章最后给出的参考网站。所谓的传统，是指在响应式设计没流行前XAML就已经存在的应对不同分辨率的技术，毕竟桌面客户端常常也调整窗体的大小，有些人还同时使用两个不同分辨率的屏幕。以我的经验来说以下这些做法可以使UI有效应对分辨率改变不同的DPI设定、不同的本地化字符串长度都可能使整个页面布局乱掉。而且和网页不同，WPF窗体默认没有提供ScrollViewer，所以千万不能忘记。在桌面客户端合理使用以上技术可以避免客户投诉。但UWP主打跨平台，它需要更先进（或者说，更激进）的技术。微软的官方文档介绍了UWP中响应式设计常用的6个技术，包括重新定位、调整大小、重新排列、显示/隐藏、替换和重新构建，具体可见以下网站：UWP中部分控件已经实现了响应式行为， 最典型的就是NavigationView。可以使用 PaneDisplayMode 属性配置不同的导航样式或显示模式。默认情况下，PaneDisplayMode 设置为 Auto。在 Auto 模式下，导航视图会进行自适应，在窗口狭窄时为 LeftMinimal，接下来为 LeftCompact，随后在窗口变宽时为 Left。这种时候MVVM的优势就体现出来了，因为VIEW和VIEWMODEL解耦了，VIEW随便换，而且整个UI显示隐藏说不定比多个小模块独自改变性能更好。说到性能，UWP的很多场景都为已经死了多年的WindowsWobile考虑了性能，更不用说现在的桌面平台，所以做UWP不需要太过介意性能，尤其是已经在WPF上培养出小心翼翼的习惯的开发者，UWP的性能问题等真的出现了再说。除了使用显示隐藏，UWP还可以使用限定符名称指定CodeBehind对应的XAML文件，这有点像是自适应应用的话题。使用格式如下";
var str = bigDataRsa.EncryptBigData(data, RSAEncryptionPadding.Pkcs1);
Console.WriteLine("Big Data Encrypt:");
Console.WriteLine(str);
Console.WriteLine("Big Data Decrypt:");
Console.WriteLine(string.Join("", bigDataRsa.DecryptBigData(str, RSAEncryptionPadding.Pkcs1)));
Console.ReadKey();
}
static void Main(string[] args)
{
string filePath = Environment.CurrentDirectory;
if (args.Length != 0)
{
filePath = args[0];
}
var keyList = RsaKeyGenerator.Pkcs1Key(2048, false);
var privateKey = keyList[0];
var publicKey = keyList[1];
Console.WriteLine("生成成功！编码UTF-8");
Console.WriteLine("私钥：");
Console.WriteLine(privateKey);
Console.WriteLine("公钥：");
Console.WriteLine(publicKey);
if (!Directory.Exists(filePath))
{
Directory.CreateDirectory(filePath);
}
File.WriteAllText(Path.Combine(filePath, "私钥.txt"), privateKey, Encoding.UTF8);
File.WriteAllText(Path.Combine(filePath, "公钥.txt"), publicKey, Encoding.UTF8);
Console.WriteLine("按任意键退出");
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine(RsaKeyGenerator.XmlKey(2048)[0]);
Console.WriteLine(RsaKeyGenerator.Pkcs1Key(2048, true)[0]);
Console.WriteLine(RsaKeyGenerator.Pkcs8Key(2048, true)[0]);
Console.WriteLine("Key Convert:");
var keyList = RsaKeyGenerator.Pkcs1Key(2048, false);
var privateKey = keyList[0];
var publicKey = keyList[1];
Console.WriteLine("public key pkcs1->xml:");
Console.WriteLine(RsaKeyConvert.PublicKeyPemToXml(publicKey));
var bigDataRsa = new RsaPkcs1Util(Encoding.UTF8, publicKey, privateKey, 2048);
var str = bigDataRsa.EncryptBigData("abcdefg", 3, "$", RSAEncryptionPadding.Pkcs1);
Console.WriteLine("Big Data Encrypt:");
Console.WriteLine(str);
Console.WriteLine("Big Data Decrypt:");
Console.WriteLine(string.Join("", bigDataRsa.DecryptBigData(str, "$", RSAEncryptionPadding.Pkcs1)));
Console.ReadKey();
}
public SensitiveDataKeyIdTests()
{
var keyGenerator = new RsaKeyGenerator();
var keyStore = new InMemoryRsaKeyStore(keyGenerator);
var provider = new RsaEncryptionProvider(keyStore);
_engine = new FieldCryptoEngine(provider);
}
/// <summary>
/// XML格式的RSA密钥
/// </summary>
/// <returns></returns>
public static string CreateXMLKey()
{
var keyList = RsaKeyGenerator.XmlKey(2048);
var privateKey = keyList[0];
var publicKey = keyList[1];
return($"私钥：{privateKey}\n公钥：{publicKey}");
}
public void SetUp()
{
rsaKeyGenerator = new RsaKeyGenerator();
var rabinMillerTest = new RabinMillerTest(20);
primeGenerator = new PrimeGenerator(rabinMillerTest);
keyGenerator = new KeyGenerator(rsaKeyGenerator, primeGenerator);
}
/// <summary>
/// Pkcs8格式的RSA密钥
/// </summary>
/// <returns></returns>
public static string CreatePkcs8Key()
{
var keyList = RsaKeyGenerator.Pkcs8Key(2048, true);
var privateKey = keyList[0];
var publicKey = keyList[1];
return($"私钥：{privateKey}\n公钥：{publicKey}");
}
public FieldCryptoEngineReferenceMembersTests()
{
var keyGenerator = new RsaKeyGenerator();
var keyStore = new InMemoryRsaKeyStore(keyGenerator);
var provider = new RsaEncryptionProvider(keyStore);
_engine = new FieldCryptoEngine(provider);
}
public void Given_ValidKey_When_WriteToFile_Then_PublicAndPrivateKeyEncodedAndWrittenToFile()
{
// Arrange
var privateKey = new RsaKeyGenerator().GetNewKey(new RsaKeyGenerationOptions()
{
KeySize = 384,
UseOaepPadding = true,
NewKeyName = "test"
});
var pocoMapper = new Mock <IKeyToExternalRepresentationMapper <RsaKey, EnvCryptKey> >();
pocoMapper.Setup(m => m.Map(It.IsAny <RsaKey>(), It.IsAny <EnvCryptKey>())).Callback <RsaKey, EnvCryptKey>((key, keyXml) => keyXml.Type = key.Key.D == null ? KeyTypeEnum.Public.ToString() : keyXml.Type = KeyTypeEnum.Private.ToString());
const string privateKeyXmlContents = @"<EnvCryptKey Type=""Private"" ... > ...";
const string publicKeyXmlContents = @"<EnvCryptKey Type=""Public"" ... > ...";
var usedEncoding = Encoding.UTF32;
var serialisationUtil = new Mock <IXmlSerializationUtils <EnvCryptKey> >();
serialisationUtil.Setup(u => u.Serialize(It.Is <EnvCryptKey>(p => p.Type == KeyTypeEnum.Private.ToString()))).Returns(privateKeyXmlContents);
serialisationUtil.Setup(u => u.Serialize(It.Is <EnvCryptKey>(p => p.Type == KeyTypeEnum.Public.ToString()))).Returns(publicKeyXmlContents);
serialisationUtil.Setup(u => u.GetUsedEncoding()).Returns(usedEncoding);
var writer = new Mock <IStringWriter <StringToFileWriterOptions> >();
const string privateKeyFile = @"C:\some\path\privatekey.xml";
const string publicKeyFile = @"C:\some\path\publickey.xml";
var opts = new AsymmetricKeyFilePersisterOptions()
{
NewPrivateKeyFullFilePath = privateKeyFile,
NewPublicKeyFullFilePath = publicKeyFile,
OverwriteFileIfExists = true
};
// Act
var persister = new RsaKeyPersister(pocoMapper.Object, serialisationUtil.Object, writer.Object);
persister.Persist(privateKey, opts);
// Assert
serialisationUtil.Verify(u => u.Serialize(It.Is <EnvCryptKey>(p => p.Type == KeyTypeEnum.Private.ToString())), Times.Once);
writer.Verify(w => w.Write(new StringToFileWriterOptions()
{
Path = privateKeyFile,
Contents = privateKeyXmlContents,
OverwriteIfFileExists = true,
Encoding = usedEncoding
}), Times.Once);
serialisationUtil.Verify(u => u.Serialize(It.Is <EnvCryptKey>(p => p.Type == KeyTypeEnum.Public.ToString())), Times.Once);
writer.Verify(w => w.Write(new StringToFileWriterOptions()
{
Path = publicKeyFile,
Contents = publicKeyXmlContents,
OverwriteIfFileExists = true,
Encoding = usedEncoding
}), Times.Once);
}
static void Main(string[] args)
{
var keyList = RsaKeyGenerator.XmlKey(2048);
var privateKey = keyList[0];
var publicKey = keyList[1];
Console.WriteLine(RsaKeyGenerator.XmlKey(2048)[0]);
Console.WriteLine(RsaKeyGenerator.Pkcs1Key(2048, true)[0]);
Console.WriteLine(RsaKeyGenerator.Pkcs8Key(2048, true)[0]);
Console.ReadKey();
}
private int OnExecute(CommandLineApplication app)
{
if (app.Options.Count == 1 && app.Options[0].ShortName == "h")
{
app.ShowHelp();
}
try
{
bool pemFormat = bool.Parse(PemFormat);
string publicKey = string.Empty;
string privateKey = string.Empty;
List <string> keyList;
switch (Format)
{
case "xml":
keyList = RsaKeyGenerator.XmlKey(KeySize);
privateKey = keyList[0];
publicKey = keyList[1];
break;
case "pkcs1":
keyList = RsaKeyGenerator.Pkcs1Key(KeySize, pemFormat);
privateKey = keyList[0];
publicKey = keyList[1];
break;
case "pkcs8":
keyList = RsaKeyGenerator.Pkcs8Key(KeySize, pemFormat);
privateKey = keyList[0];
publicKey = keyList[1];
break;
}
if (!Directory.Exists(Output))
{
Directory.CreateDirectory(Output);
}
File.WriteAllText(Path.Combine(Output, "public.key"), publicKey);
File.WriteAllText(Path.Combine(Output, "private.key"), privateKey);
app.Out.WriteLine($"Process success.File saved in {Output}.");
}
catch (Exception e)
{
app.Out.WriteLine($"Process error.Detail message:{e.Message}");
return(1);
}
return(0);
}
public void AgentCreateDeviceSetRsaKey()
{
// generate RSA key pair
RsaKeyGenerator generator = new RsaKeyGenerator();
RsaPrivateKey privateKey = generator.GeneratePrivateKey(2048);
RsaPublicKey publicKey = generator.GeneratePublicKey(privateKey);
// set RSA keys into a CreateDeviceRequest object
CreateDeviceRequest request = new CreateDeviceRequest();
request.ClientRsaPrivateKey = privateKey;
request.ClientRsaPublicKey = publicKey;
}
public void EncryptDecrypt_R2048_JSON_Test()
{
var key = RsaKeyGenerator.Generate(AsymmetricKeyMode.Both, RsaKeySize.L2048, RsaKeyFormat.JSON);
var function = RsaFactory.Create(key);
#if NET451 || NET452
var cipherVal = function.EncryptByPublicKey("image", true);
var originVal = function.DecryptByPrivateKey(cipherVal.CipherData, true);
#else
var cipherVal = function.EncryptByPublicKey("image", RSAEncryptionPadding.OaepSHA1);
var originVal = function.DecryptByPrivateKey(cipherVal.CipherData, RSAEncryptionPadding.OaepSHA1);
#endif
Assert.Equal("image", originVal.GetOriginalDataDescriptor().GetString());
}
/// <summary>
/// Create RSA key
/// </summary>
/// <param name="meta">Key's metadata</param>
/// <returns>Cipherkey object</returns>
public async Task <CipherKey> CreateKeyAsync()
{
var keys = RsaKeyGenerator.Pkcs8Key(2048, false);
var privateKey = keys[0];
var publicKey = keys[1];
var key = new CipherKey()
{
Id = Guid.NewGuid().ToString(),
KeyType = KeyTypeEnum.RSA,
PublicKey = publicKey,
PrivateKey = privateKey
};
return(await Task.FromResult(key));
}
private static void GenerateKeys()
{
var keys = RsaKeyGenerator.Pkcs8Key(rsaKeySize, true);
string privateKey = keys[0];
string publicKey = keys[1];
string path = Path.Combine(rootPath, keyPath);
string privateKeyPath = Path.Combine(path, privateKeyFileName);
string publicKeyPath = Path.Combine(path, publicKeyFileName);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
File.WriteAllText(privateKeyPath, privateKey);
File.WriteAllText(publicKeyPath, publicKey);
}
public void Given_AnyKey_When_GetNewKey_Then_NameIsInObject()
{
// Arrange
var generator = new RsaKeyGenerator();
var newKeyName = "my new key";
// Act
var newKey = generator.GetNewKey(new RsaKeyGenerationOptions()
{
KeySize = 384,
UseOaepPadding = true,
NewKeyName = newKeyName
});
// Assert
newKey.Name.Should().Be(newKeyName);
}
public void Given_KeySize_When_GetNewKey_Then_KeySizeMatches(
[Range(384, 1024, 8)] int actualKeySize)
{
// Arrange
var generator = new RsaKeyGenerator();
// Act
var newKey = generator.GetNewKey(new RsaKeyGenerationOptions()
{
KeySize = actualKeySize,
UseOaepPadding = true,
NewKeyName = "test"
});
// Assert
newKey.GetKeySize().Should().Be(actualKeySize);
}
static void Main(string[] args)
{
Console.WriteLine(RsaKeyGenerator.XmlKey(2048)[0]);
Console.WriteLine(RsaKeyGenerator.Pkcs1Key(2048, true)[0]);
Console.WriteLine(RsaKeyGenerator.Pkcs8Key(2048, true)[0]);
Console.WriteLine("Key Convert:");
var keyList = RsaKeyGenerator.Pkcs1Key(2048, false);
var privateKey = keyList[0];
var publicKey = keyList[1];
Console.WriteLine("public key pkcs1->xml:");
Console.WriteLine(RsaKeyConvert.PublicKeyPemToXml(publicKey));
Console.ReadKey();
}
public void Given_ValidKeyWithoutOAEP_When_GetMaxBytes_CorrectMaxBytesReturned(
[Values(384, 2048, 2056)] int keySize)
{
// Arrange
var generator = new RsaKeyGenerator();
var aNewKey = generator.GetNewKey(new RsaKeyGenerationOptions()
{
KeySize = keySize,
UseOaepPadding = false,
NewKeyName = "test"
});
// Act
var actualMaxBytes = new RsaMaxEncryptionCalc().GetMaxBytesThatCanBeEncrypted(aNewKey);
// Assert
actualMaxBytes.Should().Be(((keySize - 384) / 8) + 37);
}
public void Given_ValidKey_When_GetKeySize_Then_CorrectKeySizeReturned(
[Values(384, 2048, 2056)] int keySize)
{
// Arrange
var generator = new RsaKeyGenerator();
var aNewKey = generator.GetNewKey(new RsaKeyGenerationOptions()
{
KeySize = keySize,
UseOaepPadding = true,
NewKeyName = "test"
});
// Act
var actualKeySize = aNewKey.GetKeySize();
// Assert
actualKeySize.Should().Be(keySize);
}
void OnGenRsaKey()
{
var dialog = new WPFFolderBrowserDialog();
if (dialog.ShowDialog() != true)
{
return;
}
var keyDir = dialog.FileName;
var xmlKey = RsaKeyGenerator.Pkcs8Key(2048, true);
File.WriteAllText(Path.Combine(keyDir, $"{DateTime.Now:yyyyMMddHHmmssfff}.private"), xmlKey[0]);
File.WriteAllText(Path.Combine(keyDir, $"{DateTime.Now:yyyyMMddHHmmssfff}.public"), xmlKey[1]);
Process.Start("explorer.exe", keyDir);
// new RsaXmlUtil().PrivateRsa.
}
public void Given_ValidKeyGenerationOptions_When_GetNewKey_Then_PrivateKeyReturned(
[Range(384, 1024, 8)] int actualKeySize)
{
// Arrange
var generator = new RsaKeyGenerator();
// Act
var newKey = generator.GetNewKey(new RsaKeyGenerationOptions()
{
KeySize = actualKeySize,
UseOaepPadding = true,
NewKeyName = "test"
});
// Assert
newKey.Key.Should().NotBeNull();
newKey.UseOaepPadding.Should().BeTrue();
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var keyList = RsaKeyGenerator.Pkcs8Key(2048, true);
var privateKey = keyList[0];
var publicKey = keyList[1];
var str = "我是原字符串";
Console.WriteLine($"原字符串:{str}");
str = RsaHelper.JavaRsaEncrypt(str, publicKey, RsaSignFormat.Hex);
Console.WriteLine($"Rsa加密符串:{str}");
str = RsaHelper.JavaRsaDecrypt(str, privateKey, RsaSignFormat.Hex);
Console.WriteLine($"Rsa解密符串:{str}");
var sign = RsaHelper.JavaRsaSign(str, privateKey, RsaSignFormat.Hex);
Console.WriteLine($"Rsa签名:{sign}");
Console.WriteLine($"Rsa验签:{RsaHelper.JavaRsaSignVerify(str, sign, publicKey, RsaSignFormat.Hex)}");
Console.Read();
}
static void Main(string[] args)
{
var keyList = RsaKeyGenerator.Pkcs1Key(2048, true);
Console.WriteLine($"Public key:\n{keyList.PublicKey}\n\nPrivate key:\n{keyList.PrivateKey}");
Console.Write("String for encrypt: ");
var test_string = Console.ReadLine();
var rsa_encryptor = new RsaPkcs1Util(Encoding.UTF8, keyList.PublicKey);
var encrypted_string = rsa_encryptor.Encrypt(test_string, RSAEncryptionPadding.Pkcs1);
Console.WriteLine($"\nEncrypted string:\n{encrypted_string}\n");
var rsa_decryptor = new RsaPkcs1Util(Encoding.UTF8, keyList.PublicKey, keyList.PrivateKey);
var decrypted_string = rsa_decryptor.Decrypt(encrypted_string, RSAEncryptionPadding.Pkcs1);
Console.WriteLine($"\nDecrypted string:\n{decrypted_string}\n");
Console.WriteLine("\nPress any key to exit");
Console.ReadKey();
}
public void Given_ValidKeyAndBinaryData_When_EncryptAndDecrypt_Then_DecryptionIsSameResult(
[Values(2040, 2048, 2056)] int keySize)
{
// Arrange
const string strToTestWith = "encrypt this string and get the same after decryption";
var converter = new Utf16LittleEndianUserStringConverter();
var strAsBytes = converter.Encode(strToTestWith);
var key = new RsaKeyGenerator().GetNewKey(new RsaKeyGenerationOptions()
{
NewKeyName = "test",
KeySize = keySize,
UseOaepPadding = true
});
// Act
var algo = new RsaAlgo();
var result = algo.Decrypt(algo.Encrypt(strAsBytes, key), key);
// Assert
converter.Decode(result).Should().Be(strToTestWith);
}
/// <summary>
/// 生成公私钥对
/// </summary>
public static void CreateRSAKey()
{
var keyList = RsaKeyGenerator.XmlKey(2048);
var privateKey = keyList[0];
var publicKey = keyList[1];
// XML
Console.WriteLine(RsaKeyGenerator.XmlKey(2048)[0]);
Console.WriteLine("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
Console.WriteLine(RsaKeyGenerator.XmlKey(2048)[1]);
Console.WriteLine("================================================================================");
// Pkcs1
Console.WriteLine(RsaKeyGenerator.Pkcs1Key(2048, true)[0]);
Console.WriteLine("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
Console.WriteLine(RsaKeyGenerator.Pkcs1Key(2048, true)[1]);
Console.WriteLine("================================================================================");
// Pkcs8
Console.WriteLine(RsaKeyGenerator.Pkcs8Key(2048, true)[0]);
Console.WriteLine("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
Console.WriteLine(RsaKeyGenerator.Pkcs8Key(2048, true)[1]);
Console.ReadKey();
}
public RsaKeyPair(RsaKeyType keyType, int keySize)
{
List <string> keys;
switch (keyType)
{
case RsaKeyType.XML:
keys = RsaKeyGenerator.XmlKey(keySize);
break;
case RsaKeyType.Pkcs1:
keys = RsaKeyGenerator.Pkcs1Key(keySize, false);
break;
case RsaKeyType.Pkcs8:
keys = RsaKeyGenerator.Pkcs8Key(keySize, false);
break;
default:
throw new ArgumentException("Key类型不存在");
}
PrivateKey = keys[0];
PublicKey = keys[1];
}
protected override void ProcessRecord()
{
try
{
DenConfigController denConfigController = new DenConfigController(this.Path, this.Key);
if (denConfigController.DbExists)
{
this.DenConfig = denConfigController.GetConfig();
this.UpdateConfig();
}
else
{
if (string.IsNullOrEmpty(this.Platform))
{
this.Platform = "Linux";
}
Platforms platform = this.Platform.Equals("Linux") ? Platforms.Linux : Platforms.Windows;
RsaKeyGenerator rsaKeyGenerator = new RsaKeyGenerator();
this.DenConfig = new DenConfig()
{
DenDockerConfigObject = new DenDockerConfigObject
{
DockerClientUri = string.IsNullOrEmpty(this.DockerClientUri) ? this.DockerDefaultEndpoint : this.DockerClientUri,
Platform = platform.ToString(),
SyslogServer = this.SyslogServer
},
DenMongoConfigObject = new DenMongoConfigObject
{
Url = !string.IsNullOrEmpty(this.MongoUrl) ? this.MongoUrl : DEFAULT_MONGO_URL
},
DenPickyConfigObject = new DenPickyConfigObject
{
ApiKey = DenServiceUtils.GenerateRandom(32),
Backend = "mongodb",
Realm = this.Realm
},
DenLucidConfigObject = new DenLucidConfigObject
{
AdminSecret = DenServiceUtils.GenerateRandom(10),
AdminUsername = DenServiceUtils.GenerateRandom(16),
ApiKey = DenServiceUtils.GenerateRandom(32)
},
DenServerConfigObject = new DenServerConfigObject
{
ApiKey = DenServiceUtils.GenerateRandom(32),
AuditTrails = "true",
ExternalUrl = this.ExternalUrl,
LDAPPassword = this.LDAPPassword != null ? this.LDAPPassword : string.Empty,
LDAPServerUrl = this.LDAPServerUrl != null ? this.LDAPServerUrl : string.Empty,
LDAPUserGroup = this.LDAPUserGroup != null ? this.LDAPUserGroup : string.Empty,
LDAPUsername = this.LDAPUsername != null ? this.LDAPUsername : string.Empty,
LDAPServerType = this.LDAPServerType != null ? this.LDAPServerType : string.Empty,
LDAPBaseDN = this.LDAPBaseDN != null ? this.LDAPBaseDN : string.Empty,
PrivateKey = KeyCertUtils.PemToDer(rsaKeyGenerator.PrivateKey),
JetServerUrl = this.JetServerUrl != null ? this.JetServerUrl : string.Empty,
JetRelayUrl = this.JetRelayUrl != null ? this.JetRelayUrl : string.Empty,
LoginRequired = this.LoginRequired ? "True": "False",
PublicKey = KeyCertUtils.PemToDer(rsaKeyGenerator.PublicKey),
NatsUsername = this.NatsUsername,
NatsPassword = this.NatsPassword,
RedisPassword = this.RedisPassword
},
DenTraefikConfigObject = new DenTraefikConfigObject
{
WaykDenPort = this.WaykDenPort != null ? this.WaykDenPort : "4000",
Certificate = this.CertificatePath != null ? this.CertificatePath : string.Empty,
PrivateKey = this.PrivateKeyPath != null ? this.PrivateKeyPath : string.Empty
},
DenImageConfigObject = new DenImageConfigObject(platform)
};
}
denConfigController.StoreConfig(this.DenConfig);
Environment.SetEnvironmentVariable(WAYK_DEN_HOME, this.Path);
}
catch (Exception e)
{
this.OnError(e);
}
base.ProcessRecord();
}
/// <summary>
/// 获得私钥和公钥
/// [0]=privateKey 私钥
/// [1]=publicKey 公钥
/// </summary>
/// <returns></returns>
public static List <string> GetKey()
{
return(RsaKeyGenerator.Pkcs1Key(2048, true));
}
/// <summary> /// Generate XML Format RSA Key. /// </summary> /// <param name="mode"></param> /// <param name="keySize"></param> /// <returns></returns> public static RsaKey GenerateKeyInXml(AsymmetricKeyMode mode, RsaKeySize keySize) => RsaKeyGenerator.GenerateInXml(mode, keySize);
