public void GivenRandomData_WhenEncryptingData_ThenSessionKeyIsReturned()
{
var currentUser = WindowsIdentity.GetCurrent()
.Name;
var target = new RSAEncryption("target", currentUser);
new RSAEncryption("signatureContainer", currentUser);
var targetPublicKey = target.ExportKey(false);
HybridEncryption hybridEncryption = HybridEncryption.CreateEncryption(targetPublicKey, "signatureContainer");
RandomNumberGenerator random = new RNGCryptoServiceProvider();
var data = new byte[512];
var sessionKey = new byte[32];
var iv = new byte[16];
random.GetBytes(sessionKey);
random.GetBytes(iv);
random.GetBytes(data);
var encryptedResult = hybridEncryption.EncryptData(sessionKey, data, iv);
Assert.That(encryptedResult.key.SessionKey, Is.Not.Empty);
}
public void RSAEncryptionTestInitialize()
{
var keys = RSAEncryption.GenerateKeys();
publicKey = keys[0];
privateKey = keys[1];
}
public IActionResult RequestStoreKeys(InfoClients infoClients)
{
//Write Event
var jsonObj = JsonConvert.SerializeObject(infoClients);
FileWriter.WriteOnEvents(EventLevel.Info,
"Request en RequestStoreKeys ObjKeyService recibido " + string.Join(", ", jsonObj));
//Store partner's public key
FileWriter.WriteOnFile(parameters.Value.FilesOutput,
parameters.Value.PubKeyFile + infoClients.userNameOrigin + infoClients.userNameDestination, infoClients.keyEncrypt);
FileWriter.WriteOnEvents(EventLevel.Info,
"Llave publica de " + infoClients.userNameOrigin + infoClients.userNameDestination + " almacenada.");
//Delete and generate the own RSA Keys
infoClients.keyEncrypt = "";
RSAEncryption rsaEncryption = new RSAEncryption();
string filePublicKey = parameters.Value.FilesOutput + parameters.Value.PubKeyFile + infoClients.userNameOrigin + infoClients.userNameDestination;
infoClients.keyEncrypt = rsaEncryption.GeneratePubPrivKeys(infoClients.userNameOrigin + infoClients.userNameDestination, filePublicKey);
//Inverting usernames origin-destination
string auxUserName = infoClients.userNameOrigin;
infoClients.userNameOrigin = infoClients.userNameDestination;
infoClients.userNameDestination = auxUserName;
if (infoClients.keyEncrypt != "")
{
FileWriter.WriteOnEvents(EventLevel.Info, "Devolviendo llaves generadas.");
return(Ok(infoClients));
}
else
{
FileWriter.WriteOnEvents(EventLevel.Error, "Error generando llaves.");
return(BadRequest(infoClients));
}
}
public IActionResult ReceiveMessage(SendMessageModel messageModel)
{
string filePublicKey = parameters.Value.FilesOutput + parameters.Value.PubKeyFile + messageModel.userNameDestination + messageModel.userNameOrigin;
RSAEncryption rsaEncryption = new RSAEncryption();
AESEncryption aesEncryption = new AESEncryption();
RSASigning rsaSigning = new RSASigning();
//Decrypt symmetric key
ResponseRSADecryption rsaDecryptResponse = new ResponseRSADecryption();
rsaDecryptResponse = rsaEncryption.DecryptAESKey(messageModel.encryptedKey, messageModel.userNameDestination + messageModel.userNameOrigin);
if (!rsaDecryptResponse.result)
{
FileWriter.WriteOnEvents(EventLevel.Error, "Error descifrando llave AES con RSA.");
return(BadRequest(new { result = false }));
}
//Decrypt Message
ResponseAESDecryption responseAESDecryption = new ResponseAESDecryption();
responseAESDecryption = aesEncryption.DecryptMessage(messageModel, rsaDecryptResponse.decryptedKey);
if (!responseAESDecryption.result)
{
FileWriter.WriteOnEvents(EventLevel.Error, "Error descifrando mensaje con AES.");
return(BadRequest(new { result = false }));
}
//Validate Sign
if (!rsaSigning.validateSignAndHash(responseAESDecryption.decryptedMessage, messageModel.encryptSignature, filePublicKey))
{
FileWriter.WriteOnEvents(EventLevel.Atention, "La información recibida es corrupta.");
return(BadRequest(new { result = false }));
}
//Muestra mensaje
return(Ok(new{ mensaje = responseAESDecryption.decryptedMessage }));
}
/// <summary>
/// 上传用户签名/印章图片
/// </summary>
/// <param name="account">用户唯一标识</param>
/// <param name="imageData">图片文件内容</param>
/// <param name="imageName">签名/印章图片名称</param>
/// <returns></returns>
public BaseResult <CommonResult> UserUpload(string account, string imageData, string imageName = "")
{
Dictionary <string, object> requestParams = new Dictionary <string, object>();
requestParams.Add("account", account);
requestParams.Add("imageData", imageData);
if (string.IsNullOrWhiteSpace(imageName))
{
requestParams.Add("imageName", imageName);
}
SortedDictionary <string, object> keyValues = new SortedDictionary <string, object>();
keyValues.Add("developerId", Constants.DeveloperID);
keyValues.Add("rtick", SignUtils.ToUnixEpochDate(DateTime.Now).ToString() + SignUtils.ToRandom(1000, 9999));
keyValues.Add("signType", Constants.SignType);
var signResult = SignUtils.GenerateSign(Constants.Path + Constants.SignatureImage_User_Upload, SignUtils.GenerateMD5(requestParams), keyValues);
var signEncryResult = RSAEncryption.SignData(signResult, Constants.PrivateKey);
var signEncodeResult = SignUtils.SignUrlEncode(signEncryResult);
keyValues.Add("sign", signEncodeResult);
var originalUrl = Constants.Host + Constants.Path + Constants.SignatureImage_User_Upload;
var requestUrl = SignUtils.GenerateUrl(originalUrl, keyValues);
BaseResult <CommonResult> result = httpService.HttpPost <BaseResult <CommonResult> >(requestUrl, requestParams);
return(result);
}
public void GivenEncryptionKeyBlob_WhenImportingKey_ThenImportsSessionKeyCorrectly()
{
var currentUser = WindowsIdentity.GetCurrent()
.Name;
var target = new RSAEncryption("target", currentUser);
new RSAEncryption("signatureContainer", currentUser);
var targetPublicKey = target.ExportKey(false);
HybridEncryption hybridEncryption = HybridEncryption.CreateEncryption(targetPublicKey, "signatureContainer");
RandomNumberGenerator random = new RNGCryptoServiceProvider();
var data = File.ReadAllBytes("appsettings.json");
var sessionKey = new byte[32];
var iv = new byte[16];
random.GetBytes(sessionKey);
random.GetBytes(iv);
(EncryptionSettings key, byte[] encryptedData)encryptedResult = hybridEncryption.EncryptData(sessionKey, data, iv);
var key = encryptedResult.key;
var keyBlob = key.ExportToBlob();
var keyFromBlob = EncryptionSettings.FromBlob(keyBlob);
Assert.That(keyFromBlob.SessionKey, Is.EqualTo(key.SessionKey));
}
public IActionResult CreateMessage(CreateMessageModel model)
{
if (ModelState.IsValid)
{
var email = new Message
{
EmailSender = User.Identity.Name,
EmailReceiver = model.EmailReceiver,
Text = model.Text,
AttachedFile = model.File
};
var rsaEncryption = new RSAEncryption(email.EmailReceiver);
var digitalSignature = new DigitalSignature(email.EmailSender);
var encryptedMessage = _messageEncryptionService.EncryptData(email, rsaEncryption, digitalSignature);
if (email.AttachedFile != null)
{
_fileEncryptionService.EncryptFile(email.AttachedFile, encryptedMessage, rsaEncryption, digitalSignature);
}
return(RedirectToAction(nameof(MessageSentSuccessfully)));
}
return(View());
}
public RSAEncryption GetPrivateKey()
{
if (!GenerateInBackground)
{
return(GenerateRsaKey());
}
if (PrivateKeys.Count == 0)
{
if (GenThread == null)
{
GenThread = new Thread(new ThreadStart(GenerateThread));
GenThread.Start();
}
return(GenerateRsaKey());
}
else
{
lock (PrivateKeys)
{
//get a random key
int index = rnd.Next(0, PrivateKeys.Count - 1);
RSAEncryption RSA = PrivateKeys[index];
PrivateKeys.RemoveAt(index);
if (PrivateKeys.Count < Min_Private_Keys && GenThread == null)
{
GenThread = new Thread(new ThreadStart(GenerateThread));
GenThread.Start();
}
return(RSA);
}
}
}
/// <summary>
/// 异步申请状态查询
/// </summary>
/// <param name="account">用户唯一标识</param>
/// <param name="taskId">任务单号</param>
/// <returns></returns>
public BaseResult <AsyncApplyCertStatusResult> AsyncApplyCertStatus(string account, string taskId)
{
Dictionary <string, object> requestParams = new Dictionary <string, object>();
requestParams.Add("account", account);
requestParams.Add("taskId", taskId);
SortedDictionary <string, object> keyValues = new SortedDictionary <string, object>();
keyValues.Add("developerId", Constants.DeveloperID);
keyValues.Add("rtick", SignUtils.ToUnixEpochDate(DateTime.Now).ToString() + SignUtils.ToRandom(1000, 9999));
keyValues.Add("signType", Constants.SignType);
var signResult = SignUtils.GenerateSign(Constants.Path + Constants.User_Async_ApplyCert_Status, SignUtils.GenerateMD5(requestParams), keyValues);
var signEncryResult = RSAEncryption.SignData(signResult, Constants.PrivateKey);
var signEncodeResult = SignUtils.SignUrlEncode(signEncryResult);
keyValues.Add("sign", signEncodeResult);
var originalUrl = Constants.Host + Constants.Path + Constants.User_Async_ApplyCert_Status;
var requestUrl = SignUtils.GenerateUrl(originalUrl, keyValues);
BaseResult <AsyncApplyCertStatusResult> result = httpService.HttpPost <BaseResult <AsyncApplyCertStatusResult> >(requestUrl, requestParams);
return(result);
}
public void GivenUsername_WhenCreatingContainer_ThenSetsAccessControlToReadOnlyForUser()
{
var containerName = $"{Guid.NewGuid()}";
var rsaEncryption = new RSAEncryption(containerName, User);
var rsaCryptoServiceProvider = new RSACryptoServiceProvider(new CspParameters()
{
KeyContainerName = containerName
});
rsaEncryption.ExportKey(false);
var path = Path.Combine(WellKnownPaths.RSA_MACHINEKEYS, rsaCryptoServiceProvider.CspKeyContainerInfo.UniqueKeyContainerName);
FileSecurity fSecurity = new FileSecurity(path, AccessControlSections.Access);
var accessRule = fSecurity.GetAccessRules(true, true, typeof(NTAccount))
.Cast <FileSystemAccessRule>()
.SingleOrDefault();
var rights = accessRule.FileSystemRights
.ToString()
.Split(',')
.Select(x => (FileSystemRights)Enum.Parse(typeof(FileSystemRights), x, true));
Assert.NotNull(rights);
Assert.That(rights.Count(), Is.EqualTo(1));
Assert.That(rights.Any(systemRights => systemRights == FileSystemRights.FullControl));
}
/// <summary>
/// 获取合同签署参数
/// </summary>
/// <param name="contractId">合同编号</param>
/// <param name="account">签署者</param>
/// <returns></returns>
public BaseResult <GetSignerConfigResult> GetSignerConfig(string contractId, string account)
{
Dictionary <string, object> requestParams = new Dictionary <string, object>();
requestParams.Add("contractId", contractId);
requestParams.Add("account", account);
SortedDictionary <string, object> keyValues = new SortedDictionary <string, object>();
keyValues.Add("developerId", Constants.DeveloperID);
keyValues.Add("rtick", SignUtils.ToUnixEpochDate(DateTime.Now).ToString() + SignUtils.ToRandom(1000, 9999));
keyValues.Add("signType", Constants.SignType);
var signResult = SignUtils.GenerateSign(Constants.Path + Constants.Contract_GetSignerConfig, SignUtils.GenerateMD5(requestParams), keyValues);
var signEncryResult = RSAEncryption.SignData(signResult, Constants.PrivateKey);
var signEncodeResult = SignUtils.SignUrlEncode(signEncryResult);
keyValues.Add("sign", signEncodeResult);
var originalUrl = Constants.Host + Constants.Path + Constants.Contract_GetSignerConfig;
var requestUrl = SignUtils.GenerateUrl(originalUrl, keyValues);
BaseResult <GetSignerConfigResult> result = httpService.HttpPost <BaseResult <GetSignerConfigResult> >(requestUrl, requestParams);
return(result);
}
/// <summary>
/// PDF文件验签
/// </summary>
/// <param name="pdfData">PDF文件</param>
/// <returns></returns>
public BaseResult <PDFVerifySignaturesResult> VerifySignatures(string pdfData)
{
Dictionary <string, object> requestParams = new Dictionary <string, object>();
requestParams.Add("pdfData", pdfData);
SortedDictionary <string, object> keyValues = new SortedDictionary <string, object>();
keyValues.Add("developerId", Constants.DeveloperID);
keyValues.Add("rtick", SignUtils.ToUnixEpochDate(DateTime.Now).ToString() + SignUtils.ToRandom(1000, 9999));
keyValues.Add("signType", Constants.SignType);
var signResult = SignUtils.GenerateSign(Constants.Path + Constants.Pdf_VerifySignatures, "", keyValues);
var signEncryResult = RSAEncryption.SignData(signResult, Constants.PrivateKey);
var signEncodeResult = SignUtils.SignUrlEncode(signEncryResult);
keyValues.Add("sign", signEncodeResult);
var originalUrl = Constants.Host + Constants.Path + Constants.Pdf_VerifySignatures;
var requestUrl = SignUtils.GenerateUrl(originalUrl, keyValues);
BaseResult <PDFVerifySignaturesResult> result = httpService.HttpPost <BaseResult <PDFVerifySignaturesResult> >(requestUrl, requestParams);
return(result);
}
/// <summary>
/// 获取预览页URL
/// </summary>
/// <param name="contractId"></param>
/// <returns></returns>
public BaseResult <GetPreviewURLResult> GetPreviewURL(string contractId, string expireTime, string dpi = "", string account = "")
{
Dictionary <string, object> requestParams = new Dictionary <string, object>();
requestParams.Add("contractId", contractId);
requestParams.Add("expireTime", expireTime);
if (string.IsNullOrWhiteSpace(dpi))
{
requestParams.Add("dpi", dpi);
}
if (string.IsNullOrWhiteSpace(account))
{
requestParams.Add("account", account);
}
SortedDictionary <string, object> keyValues = new SortedDictionary <string, object>();
keyValues.Add("developerId", Constants.DeveloperID);
keyValues.Add("rtick", SignUtils.ToUnixEpochDate(DateTime.Now).ToString() + SignUtils.ToRandom(1000, 9999));
keyValues.Add("signType", Constants.SignType);
var signResult = SignUtils.GenerateSign(Constants.Path + Constants.Contract_GetPreviewURL, "", keyValues);
var signEncryResult = RSAEncryption.SignData(signResult, Constants.PrivateKey);
var signEncodeResult = SignUtils.SignUrlEncode(signEncryResult);
keyValues.Add("sign", signEncodeResult);
var originalUrl = Constants.Host + Constants.Path + Constants.Contract_GetPreviewURL;
var requestUrl = SignUtils.GenerateUrl(originalUrl, keyValues);
BaseResult <GetPreviewURLResult> result = httpService.HttpPost <BaseResult <GetPreviewURLResult> >(requestUrl, requestParams);
return(result);
}
/// <summary>
/// 上传合同文件
/// </summary>
/// <param name="account">用户唯一标识</param>
/// <param name="fdata">文件数据，base64编码</param>
/// <param name="fmd5">文件md5值</param>
/// <param name="ftype">文件类型</param>
/// <param name="fname">文件名</param>
/// <param name="fpages">文件页数</param>
/// <returns></returns>
public BaseResult <StorageUploadResult> Upload(string account, string fdata, string fmd5, string ftype, string fname, int fpages)
{
Dictionary <string, object> requestParams = new Dictionary <string, object>();
requestParams.Add("account", account);
requestParams.Add("fdata", fdata);
requestParams.Add("fmd5", fmd5);
requestParams.Add("ftype", ftype);
requestParams.Add("fname", fname);
requestParams.Add("fpages", fpages);
SortedDictionary <string, object> keyValues = new SortedDictionary <string, object>();
keyValues.Add("developerId", Constants.DeveloperID);
keyValues.Add("rtick", SignUtils.ToUnixEpochDate(DateTime.Now).ToString() + SignUtils.ToRandom(1000, 9999));
keyValues.Add("signType", Constants.SignType);
var signResult = SignUtils.GenerateSign(Constants.Path + Constants.Storage_Upload, SignUtils.GenerateMD5(requestParams), keyValues);
var signEncryResult = RSAEncryption.SignData(signResult, Constants.PrivateKey);
var signEncodeResult = SignUtils.SignUrlEncode(signEncryResult);
keyValues.Add("sign", signEncodeResult);
var originalUrl = Constants.Host + Constants.Path + Constants.Storage_Upload;
var requestUrl = SignUtils.GenerateUrl(originalUrl, keyValues);
BaseResult <StorageUploadResult> result = httpService.HttpPost <BaseResult <StorageUploadResult> >(requestUrl, requestParams);
return(result);
}
public void GivenEncryptingData_WhenDecryptingData_FromImportedKey_ThenDataIsDecrypted()
{
var currentUser = WindowsIdentity.GetCurrent()
.Name;
var target = new RSAEncryption("target", currentUser);
var signatureContainer = new RSAEncryption("signatureContainer", currentUser);
var signaturePublicKey = signatureContainer.ExportKey(false);
var targetPublicKey = target.ExportKey(false);
HybridEncryption hybridEncryption = HybridEncryption.CreateEncryption(targetPublicKey, "signatureContainer");
HybridDecryption hybridDecryption = HybridDecryption.CreateDecryption("target", signaturePublicKey);
RandomNumberGenerator random = new RNGCryptoServiceProvider();
var data = new byte[512];
var sessionKey = new byte[32];
var iv = new byte[16];
random.GetBytes(sessionKey);
random.GetBytes(iv);
random.GetBytes(data);
(EncryptionSettings key, byte[] encryptedData)encryptedResult = hybridEncryption.EncryptData(sessionKey, data, iv);
var keyBlob = encryptedResult.key.ExportToBlob();
var keyFromBlob = EncryptionSettings.FromBlob(keyBlob);
var decryptedData = hybridDecryption.DecryptData(keyFromBlob, encryptedResult.encryptedData);
Assert.That(decryptedData, Is.EqualTo(data));
}
private void GenerateThread()
{
try
{
while (PrivateKeys.Count < Max_Private_Keys || DiffieHellmans.Count < Max_Private_Keys)
{
if (PrivateKeys.Count < Max_Private_Keys)
{
RSAEncryption RSA = GenerateRsaKey();
lock (PrivateKeys)
{
PrivateKeys.Add(RSA);
}
}
if (DiffieHellmans.Count < Max_Private_Keys)
{
DiffieHellman diffie = GenerateDiffieHellman();
lock (DiffieHellmans)
{
DiffieHellmans.Add(diffie);
}
}
}
}
catch
{
}
GenThread = null;
}
/// <summary>
/// 注册个人用户并申请证书 | 注册企业用户并申请证书
/// </summary>
/// <param name="account">用户唯一标识</param>
/// <param name="name">用户名称</param>
/// <param name="userType">用户类型</param>
/// <param name="credential">用户证件信息对象</param>
/// <param name="applyCert"></param>
/// <param name="mail">用户邮箱</param>
/// <param name="mobile">用户手机号</param>
/// <returns></returns>
public BaseResult <RegResult> Reg(string account, string name, string userType, object credential, string applyCert, string mail = "", string mobile = "")
{
Dictionary <string, object> requestParams = new Dictionary <string, object>();
requestParams.Add("account", account);
requestParams.Add("name", name);
requestParams.Add("userType", userType);
requestParams.Add("mail", mail);
requestParams.Add("mobile", mobile);
requestParams.Add("credential", credential);
requestParams.Add("applyCert", applyCert);
SortedDictionary <string, object> keyValues = new SortedDictionary <string, object>();
keyValues.Add("developerId", Constants.DeveloperID);
keyValues.Add("rtick", SignUtils.ToUnixEpochDate(DateTime.Now).ToString() + SignUtils.ToRandom(1000, 9999));
keyValues.Add("signType", Constants.SignType);
var signResult = SignUtils.GenerateSign(Constants.Path + Constants.User_Reg, SignUtils.GenerateMD5(requestParams), keyValues);
var signEncryResult = RSAEncryption.SignData(signResult, Constants.PrivateKey);
var signEncodeResult = SignUtils.SignUrlEncode(signEncryResult);
keyValues.Add("sign", signEncodeResult);
var originalUrl = Constants.Host + Constants.Path + Constants.User_Reg;
var requestUrl = SignUtils.GenerateUrl(originalUrl, keyValues);
BaseResult <RegResult> result = httpService.HttpPost <BaseResult <RegResult> >(requestUrl, requestParams);
return(result);
}
private static void RSA_Test()
{
//RSAEncryption GenPrivateKeyc = new RSAEncryption(4096, true);
//GenPrivateKeyc.GeneratePrivateKey();
//string PrivateKey = GenPrivateKeyc.PrivateKey;
int BitSize = 4096;
string PreGenPrivateKey = @"<RSAKeyValue>
<Modulus>1ClYJTeXDkbppKjvJqC3xf+E4P4eVa4lwvFmdGTsqDdJoT+RMvLg/WkrWsCEASmxaj3ohlg1kBhSv2ZXuZlH90Roba5EWOxD1EQUDjk0e711ga0YVwZF5UUo9yx+Lo1QR3ErmeNMOkJDa0IZVnmuILgdaTFBdBm2ZYdJVnpeB+BIycNT0vAoqtwdDZXySjAzfl6nL6WsNw/XqJMIDuFcIt8hv6vghFtpiQXeWEsuZq3DQPlCu0oJDYuoAaRU5KxOIakbTzpTS11eBx+w1PDgd+VCAEVbx71sqjSFsAOEvmm4A0lRBRnQuJOdoGLNFoSePDGP9J88KfIfosMtAqFDUX2/8EsAc6B3QnpQ0un5vC2Au0xUDY0fwsKtN9yvFQPw10eRXEV+Smz4pBH+4gOEKi0RxNt3chKa0qqGG9I/CqL1/PPEtvN31Bjxc4H2vAyW3XMRNs7o9pktimaRNpwZ6sbBDi2eNY6Ty5ff7jHv0uy9DRQsreTewhXvZK6M8OcBUxLp1tkzi9zTBKTPTMXAuUF1oWDJktWDBuGnxbZcTfTvJ0X3zS8/mXdsUHsgV5vcGeT+2hZLQnskrwlbxt4QjEHSl0hgWM9i5Yhd+ltlg/9URvZdnkh5pKoShJR4OWNSBsI3kwRzwPHAKag8J4TSFIgZXCkSvtTlsM6v44f8pNU=</Modulus>
<Exponent>AQAB</Exponent>
<P>3cBHXk4SpnPWskCpGfJbW5u5XO3q1srmsW9XCDwo4HWezMaIjznjcwd46W50nUAkfS6zt91Ez7xPzWg0+kTrLwJEnAwLb5rYk7aGk29G8Vz0DW6rBnzT8hIxgdAnRUk/Htxkee1k8aHdL5kDUkfBDX1sRxi20A8bNHG039oq0joxkQKO8nrctIxHLiTtPXUH1R3AZ4+35keONp4iRBvKudPlZFOGHw4JmtW/mm6opAHOMZJyMpz6LFbQuQ6FAb7YkP63e0qELgP5PgnFgz/k2vA5gqjCfLdHNqh4o9iTuEDh8JPY4ADu3JkaJXdp3NPn2vsZHW3IJQON4WnjfFB3mQ==</P>
<Q>9O3oLQiJXD3O9aQnyUpI4MQjJ2JacXCbNmcS8Kv+U1eYpQqQK1PwJCl2jJ8KgP7Hy8H3kuUxMDFv1fuWO1UFC4fzrODx5W6Vo/ZUhud0l8q8OfQKq4YOmpHR/eFAj9Bo3bGNXnjBWCV0RmxA0cAQ/y/bAdBTOQntBQUNLqfstTu6fAMor6fzYpzic1olUlOQf9wCOHNE/JSgjMgaXdpYLxLsCSexN/ut8T8fxBSX3NeSUlLbj2CWtzEGsKwP7rwIfnZ9UUKdBCaGAj2UIi5wO2TBnEb0EhjRcOa15YThZTp+4U6LQNVJC9nK26yhBrWH2ZEft5a0nPgJLIabT90snQ==</Q>
<DP>yVS/92FPEY1uylxmq8YdKClUvIjOhMGnfkWmcTWdr11bFnTSm6dlWJTaNKYyfms0NevnA/KDfVBt7ALGxss39HBMtplA8M1YAZTgzo9ji9RnSKLH6JYBIHFgPYotfXypMG3NU94znibl2UdFerjnEEZlvo8zu+dbPdxW6j78Te7D/fKisojWRZ5vKfgg5YGR4O6oN96Giy9AcVpVphzNjLZUOSiURzHJiqiy05XQy0dQXDWoNUfM4+DWlI4YOKN7oPmCwQ/Avr6g1rCsgSPLtvQQYw6xteX5ZCjFj40dYVaXTIQPjiGKvQLMeGPY28QRaAI+pTd9Vg3KDXTEM6QjUQ==</DP>
<DQ>ENQz6rw2a+8XREuGLE99WGxBmhgo7Lh3AbLtWzoGHIXdSCHErCV1T5bFvX3EA/79jWODdkVnLs+GxqYluWfrE9LAjHVcSY5im8R2JFrM6Q0WB8lb3lM0t6wjSJVskTUZr3neo8oaRss0BQ61GXRf9pi8LJC61yV2cqzZLgZ9viofcxvodMFOeM0cxh5AiDqTqCVexbAt4kj4CxRIs4AoJPvg2fQvOhCB8ByNOzTLBnKNbDijO2PAl0+4DPWVlqq2zrGnhKjWDw3ykT7X6c1VCs+ueeVqKcAoy+AeSWnq7sCpLSPvb4H4JedOB/ABlGturSVKj5u8RzjHsJaDH2asBQ==</DQ>
<InverseQ>YTR07LDfg26rZt6gaVlxYioX/UhbjoIPnH5Gd1ZcaGBfnkzaXatHv6YDA0wuj2VmAelmdTMD21H2TgHvvRRnpsVix/+uphV71QCKPBooJke/Dba2YxRYz5UYWid/VDvtFddzw3NdQF8mzqhr/FpdrZWeLiuDHlZLmQxqNWRlpFX1w1CBMZBuv8Z2cLf//sr/rZ3bY9F6EXqLoMIOnp+Gv069pfp7xpm5Ymcz3ixmCXY0BiwHxfbw2YAQus1Q3s+GSqtVU6IYFe6VbwdcRR45WdFEMF2I6mboehN2pTAUyEkvYIYra/pfjkXrTKPTvyucR1BmObKYqg9jKIXLKH3IRA==</InverseQ>
<D>Ig0isxJ5gZabEEz22T3JUROCKbRPfRPuxpuFBKBgJV1+SU2RCdrWhoWXKkEkzqT47yLRi6JjsmVc/pA3+zdhSAvoMNZb7OO6vTpR97hxtnyBfBcihXEhzbrsaMNw2xreLCE7TL8g8GbLOE9LDsiHzIOQYN5BcZdg4Wm1uRX5uoziUdOyQ/Q8qrOaTCBpW0PiN+GMNscB3XKC+/DhRbYg2g3y9jbpWYTsaswQ1B347AzufiKjdbjbvBtSkzTjVTJcdeWU1wH29W0eVslc0ch5VnTqw21eXjAGXUkBve7Kot8H5CsjwExU5hL3JRNGdFtDpEiWIL5f4yGTt0VZF4d3bLV5q3R3l34ghdt171tShSGz013J0Z5Q/iHBgRkSR//0f8ZITe7iSkhkfZXbx7Ihi13ufBJwIdcDhT7LYKHLk/H3fgCnkAigEmT14/oZwYtW0CqnHtzbBpO+jPLIMAFbhty6GE2LKlQx91YwqMODnYRYs7e8evOeiAadLAjAxQOjNZ1J8EKfwmtmqBqfiUA5O1uJRAavuMhRw/UTMqOeBEGxosmUsV4aw9BIYASmJ9uzc7pkZdPwBlVdnHPn5MILmAcE2vYhv9bRgwUF8LRT4GkP9IW2g48WabzLhIdSu/azjT2GBnkMwz5FcwPYiFvQc3fquqVWhn9PqGN5tHq6LhE=</D>
</RSAKeyValue>";
RSAEncryption A_Rsa = new RSAEncryption(BitSize, "", PreGenPrivateKey, true);
//When generating, only the modulus and Exponent should be made public, nothing else
string PublicKeyFromA = A_Rsa.GeneratePublicKey();
string TestData = "Helllo, This is A, let's hope this message arrived well";
byte[] EncryptedData = A_Rsa.Encrypt(ASCIIEncoding.ASCII.GetBytes(TestData), 0, TestData.Length);
byte[] SignedData = A_Rsa.SignData(ASCIIEncoding.ASCII.GetBytes(TestData));
RSAEncryption B_Rsa = new RSAEncryption(BitSize, A_Rsa.PublicParameters.Value.Modulus, A_Rsa.PublicParameters.Value.Exponent, true);
byte[] DecryptedData = B_Rsa.Decrypt(EncryptedData, 0, EncryptedData.Length);
}
public void GivenValidData_WhenExportingKey_ThenReturnsExportKey()
{
RSAEncryption encryption = new RSAEncryption();
var rsaExport = encryption.ExportKey(false);
Assert.That(rsaExport, Is.Not.Null);
}
internal static RSAEncryption load_keys1(string idkeys)
{
RSAEncryption myRsa = new RSAEncryption();
string public_keys = String.Format(System.IO.Directory.GetCurrentDirectory() + "/keys/publicKey_{0}.xml", idkeys);
myRsa.LoadPublicFromXml(public_keys);
return(myRsa);
}
internal static RSAEncryption load_keysFile(string filekey)
{
RSAEncryption myRsa = new RSAEncryption();
string public_keys = filekey;
myRsa.LoadPublicFromXml(public_keys);
return(myRsa);
}
public void GivenValidData_WhenExportingKey_ThenReturnsExportedKeyToXML()
{
RSAEncryption encryption = RSAEncryption.CreateContainer("SomeContainer");
var rsaExport = encryption.ExportKey(false);
Assert.That(rsaExport, Is.Not.Null);
}
private RSAEncryption GenerateRsaKey()
{
RSAEncryption RSA = new RSAEncryption(Connection.RSA_KEY_SIZE, true);
RSA.GeneratePrivateKey();
RSA.GeneratePublicKey();
return(RSA);
}
public static RSAEncryption GetRsaEncryption()
{
if (rsaEncryption == null)
{
rsaEncryption = new RSAEncryption();
}
return(rsaEncryption);
}
private void button1_Click(object sender, EventArgs e)
{
// Compose a string that consists of three lines.
if (textBox1.Text.Length > 0 && textBox2.Text.Length > 0 && textBox3.Text.Length > 0 && textBox4.Text.Length > 0)
{
ManagementObjectSearcher mosDisks = new ManagementObjectSearcher("Select * from Win32_DiskDrive ");
foreach (ManagementObject moDisk in mosDisks.Get())
{
if (moDisk["Name"].ToString() == "\\\\.\\PHYSICALDRIVE0")
{
id = moDisk["SerialNumber"].ToString();
break;
}
}
try
{
if (textBox5.Text != "")
{
RSAEncryption myRsa = new RSAEncryption();
myRsa.LoadPublicFromXml("PublicKey.xml");
System.IO.StreamWriter file = new System.IO.StreamWriter(@textBox5.Text + "\\key-req.txt");
byte[] msg = Encoding.UTF8.GetBytes(textBox1.Text);
byte[] msg1 = Encoding.UTF8.GetBytes(textBox2.Text);
byte[] msg2 = Encoding.UTF8.GetBytes(textBox6.Text);
byte[] msg3 = Encoding.UTF8.GetBytes(textBox3.Text);
byte[] msg4 = Encoding.UTF8.GetBytes(id);
// byte[] encMessage = null;
msg = myRsa.PublicEncryption(msg);
msg1 = myRsa.PublicEncryption(msg1);
msg2 = myRsa.PublicEncryption(msg2);
msg3 = myRsa.PublicEncryption(msg3);
msg4 = myRsa.PublicEncryption(msg4);
id1 = Convert.ToBase64String(msg); id2 = Convert.ToBase64String(msg1); id3 = Convert.ToBase64String(msg2); id4 = Convert.ToBase64String(msg3);
id5 = Convert.ToBase64String(msg4);
file.WriteLine(id1); file.WriteLine(id2); file.WriteLine(id3); file.WriteLine(id4); file.WriteLine(id5);
file.Close();
MessageBox.Show("File created succefully in" + @textBox5.Text + "\\");
}
else
{
MessageBox.Show("Please select any folder");
}
}
catch (Exception ex)
{
MessageBox.Show("Please select any other folder");
}
}
else
{
MessageBox.Show("Completely Fill data");
}
}
public void GenarateKeyPair()
{
cryptoField.gameObject.SetActive(true);
publicAndPrivateKeyValuePair = RSAEncryption.GenrateKeyPair(int.Parse(sizeInput.text));
Debug.Log(publicAndPrivateKeyValuePair.Key);
Debug.Log(publicAndPrivateKeyValuePair.Value);
publicKeyText.text = publicAndPrivateKeyValuePair.Key;
privateKeyText.text = publicAndPrivateKeyValuePair.Value;
}
private RSAEncryption CreateContainer(Context context)
{
if (!context.Arguments.TryGetValue(WellKnownCommandArguments.CONTAINER_NAME, out var containerName))
{
throw new ContainerNameMissingException("Missing container name. Try export --help for more information");
}
return(RSAEncryption.FromExistingContainer(containerName));
}
public static ExportState CreateWithContainer(RSAEncryption rsaEncryption)
{
var state = new ExportState
{
_rsaEncryption = rsaEncryption
};
return(state);
}
private static string ReadEncryptedMessageUsingPublicKey(byte[] encryptedMessage)
{
RSAEncryption myRsa = new RSAEncryption();
myRsa.LoadPublicFromEmbedded(PublicKey);
byte[] decryptMsg = myRsa.PublicDecryption(encryptedMessage);
return(Encoding.UTF8.GetString(decryptMsg));
}
private static void create_keys()
{
string idkeys = create_id();
id = idkeys;
List <string> list_keys = Generate_Keys.genertate_key(idkeys);
rsa = Generate_Keys.load_keys(idkeys);
}
