public void TestEncodeAndDecode_byteArr_Key() { Console.Out.WriteLine("encode and decode"); RSAService instance = new RSAService(keysize); RSAPrivateKey privateKey = instance.ReadPrivateKey(privateKeyfile); RSAPublicKey publicKey = instance.ReadPublicKey(publicKeyfile); byte[] encData = instance.Encode(msgBytes, privateKey); byte[] decData = instance.Decode(encData, publicKey); Boolean bCompare = Compare.SafeEquals(msgBytes, decData); Assert.IsTrue(bCompare); encData = instance.Encode(msgBytes, publicKey); decData = instance.Decode(encData, privateKey); bCompare = Compare.SafeEquals(msgBytes, decData); Assert.IsTrue(bCompare); }
/// <summary> /// Decrypts the specified data. /// </summary> /// <param name="data">The data.</param> /// <returns></returns> public byte[] Decrypt(byte[] data) { using (var rsa = new RSAService(_xmlKey)) { return(rsa.DecryptArrayBlock(data)); } }
/// <summary> /// Decrypts the string. /// </summary> /// <param name="data">The data.</param> /// <param name="encoding">The encoding.</param> /// <returns></returns> public string DecryptString(string data, Encoding encoding) { using (var rsa = new RSAService(_xmlKey)) { return(rsa.DecryptString(data, encoding)); } }
//加密方法 public static string Encrypt(string msg) { //随机生成key string key = Random.Range(10000000, 99999999).ToString().Substring(0, 8); //用key加密报文 string securityData = DESservice.Encode(msg, key); //加密key string securityKey = RSAService.encriptByPublicKey(key, publickey); //Debug.Log("-----------------------------------------------"); //Debug.Log(key + " length: " + key.Length); //Debug.Log(publickey); //Debug.Log(securityKey); //Debug.Log("-----------------------------------------------"); //返回string Dictionary <string, object> data = new Dictionary <string, object>(); data.Add("securityKey", securityKey); data.Add("securityData", securityData); return(Json.Serialize(data)); }
/// <summary> /// 加密模块的创建 /// </summary> /// <param name="type">加密类型</param> /// <param name="key">加密密钥</param> private static ICryptography GetService(ServiceType type, string key) { ICryptography _cryptography = null; if (type.Equals(ServiceType.AES)) { AESService aes = new AESService(); aes.Key = key; _cryptography = aes; } else if (type.Equals(ServiceType.DES)) { ThreeDesService des = new ThreeDesService(); des.Key = key; _cryptography = des; } else if (type.Equals(ServiceType.RSA)) { RSAService rsa = new RSAService(); rsa.PublicKey = key; _cryptography = rsa; } else { } return(_cryptography); }
public async Task <ActionResult> Login(WebApplication_JS_RSA.ViewModels.LoginViewModel viewModel) { if (ModelState.IsValid) { //decrypt password var password = RSAService.GetPlainText(viewModel.EncryptedPassword); return(View(viewModel)); } else { viewModel.ErrorMessage = ""; } return(Json(viewModel)); // This doesn't count login failures towards account lockout // To enable password failures to trigger account lockout, change to shouldLockout: true //var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false); //switch (result) //{ // case SignInStatus.Success: // return RedirectToLocal(returnUrl); // case SignInStatus.LockedOut: // return View("Lockout"); // case SignInStatus.RequiresVerification: // return RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }); // case SignInStatus.Failure: // default: // ModelState.AddModelError("", "Invalid login attempt."); // return View(model); //} }
public HomeController( IStringLocalizer <HomeController> localizer, RSAService rsaService, APIDbContext dbContext) { _localizer = localizer; _rsaService = rsaService; _dbContext = dbContext; }
public ActionResult Login(string returnUrl) { var viewModel = new WebApplication_JS_RSA.ViewModels.LoginViewModel(); viewModel.PublicKey = RSAService.GetPulicKey(); ViewBag.ReturnUrl = returnUrl; return(View(viewModel)); }
public SignUpModel() { XmlService = new XmlService(); RSAService = new RSAService(); HashService = new HashService(); SymetricService = new SymetricService(); User = new UserDto(); User.Salt = Guid.NewGuid().ToString(); }
public static byte[] RSADecrypt(byte[] DataToDecrypt, bool DoOAEPPadding = false) { try { return(RSAService.Decrypt(DataToDecrypt, DoOAEPPadding)); } catch (CryptographicException e) { Console.WriteLine(e.ToString()); return(null); } }
public bool SignUp() { try { if (!Directory.Exists(DatabaseDir)) { Directory.CreateDirectory(DatabaseDir); } if (!IsUserValid()) { return(false); } var emailExists = this.CheckUniqueEmail(); if (emailExists) { this.WarningMessage = "This email already exists. Please choose another one!"; return(false); } var isEmailValid = this.isEmailValid(); if (!isEmailValid) { this.WarningMessage = "Please input a valid email!"; return(false); } var emailEncoded = Convert.ToBase64String(Encoding.UTF8.GetBytes(this.User.Email)); var filePath = Path.Combine(DatabaseDir, emailEncoded); filePath = Path.ChangeExtension(filePath, "xml"); var keyPair = RSAService.GenerateKeyPair((int)this.KeySize); User.Passphrase = HashService.SHA256Hash(User.Passphrase, User.Salt); User.IV = Convert.ToBase64String(SymetricService.RijndaelGenerateIV()); User.PrivateKey = SymetricService.RijndaelEncryptData(keyPair.PrivateKey, Convert.FromBase64String(User.Passphrase), Convert.FromBase64String(User.IV)); User.PublicKey = Convert.ToBase64String(Encoding.UTF8.GetBytes(keyPair.PublicKey)); XmlService.WriteToXml <UserDto>(filePath, User); this.InfoMessage = "Sign up successfully"; } catch (Exception ex) { this.WarningMessage = "There was an error creating your account"; return(false); } return(true); }
private void Button_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e) { byte[] bytes = new byte[] { 4, 25, 156, 243 }; long p = /*10007*/ 7; long q = /*10009*/ 13; var keys = RSAService.ZnajdzWykladnikPublicznyiPrywatny(p, q); var result = RSAService.Encode(bytes, keys[0], p * q); var inverse = RSAService.Decode(result, keys[1], p * q); int a = 0; }
public void TestGenerateKey_String_String() { Console.Out.WriteLine("generateKey"); RSAService rsa = new RSAService(keysize); if (!rsa.AreKeysPresent(privateKeyfile, publicKeyfile)) { Console.Out.WriteLine("Begin Generating RSA Key Pair."); using (FileStream fos_private = new FileStream(privateKeyfile, FileMode.Create)) { using (FileStream fos_public = new FileStream(publicKeyfile, FileMode.Create)) { rsa.GenerateKey(fos_private, fos_public); } } Console.Out.WriteLine("Finish Generating RSA Key Pair."); } Assert.IsTrue(true); }
internal bool SignFile() { if (!Validate()) { return(false); } try { var privateKey = GetPrivateKey(); RSAService.Sign(this.FileSignName, privateKey); } catch (Exception ex) { return(false); } return(true); }
public void GenerateKey() { try { string publicKey, privateKey; if (!File.Exists(KeysFile)) { RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); publicKey = rsa.ToXmlString(false); privateKey = rsa.ToXmlString(true); File.WriteAllText(KeysFile, publicKey + Environment.NewLine + privateKey); rsa.Dispose(); } else { var lines = File.ReadAllLines(KeysFile); publicKey = lines[0]; privateKey = lines[1]; } if (!File.Exists(EncFile)) { RSAService.Encrypt(publicKey, Strings.Generate(32), EncFile); SymmetricalKey = File.ReadAllText(EncFile); } else { SymmetricalKey = File.ReadAllText(EncFile); } } catch (Exception e) { } }
//解密方法 public static string Decrypt(string msg) { //解析json Dictionary <string, object> json = (Dictionary <string, object>)Json.Deserialize(msg); //如果未加密直接返回 if (!json.ContainsKey("sign")) { return(msg); } string sign = (string)json["sign"]; string conetnt = (string)json["msg"]; //验证签名 if (RSAService.VerifySignedHash(conetnt, sign, publickey)) { return(conetnt); } else { throw new System.Exception("签名验证失败 " + msg); } }
public async Task DecodeRSA() { var segment = Segments.Find(i => i.Name == JPEGResources.SegmentNameDictionary[0xDA]); byte[] bytes = FileBytes.Take(segment.SegmentEndByteIndexInFile - 2).Skip(segment.SegmentStartByteIndexInFile + 20).ToArray(); int excessBytes = bytes.Length * 8 - bytes.Length; byte[] newBytes = new byte[bytes.Length * 8]; bytes.CopyTo(newBytes, 0); FileBytes.Skip(FileBytes.Length - excessBytes).ToArray().CopyTo(newBytes, bytes.Length); long p = 10007; long q = 10009; var keys = RSAService.ZnajdzWykladnikPublicznyiPrywatny(p, q); var result = RSAService.Decode(newBytes, keys[1], p * q); result.CopyTo(FileBytes, segment.SegmentStartByteIndexInFile + 20); byte[] newFileBytes = new byte[FileBytes.Length - excessBytes]; FileBytes.Take(FileBytes.Length - excessBytes).ToArray().CopyTo(newFileBytes, 0); FileBytes = newFileBytes; Modified = true; await SaveFile(); }
public async Task EncodeRSA() { var segment = Segments.Find(i => i.Name == JPEGResources.SegmentNameDictionary[0xDA]); byte[] bytes = FileBytes.Take(segment.SegmentEndByteIndexInFile - 2).Skip(segment.SegmentStartByteIndexInFile + 20).ToArray(); long p = 10007; long q = 10009; var keys = RSAService.ZnajdzWykladnikPublicznyiPrywatny(p, q); var result = RSAService.Encode(bytes, keys[0], p * q); int takeSkip = segment.SegmentEndByteIndexInFile - 2 - segment.SegmentStartByteIndexInFile - 20; result.Take(takeSkip) .ToArray() .CopyTo(FileBytes, segment.SegmentStartByteIndexInFile + 20); var newFileBytes = new byte[FileBytes.Length + result.Length - takeSkip]; FileBytes.CopyTo(newFileBytes, 0); result.Skip(takeSkip).ToArray().CopyTo(newFileBytes, FileBytes.Length); FileBytes = newFileBytes; Modified = true; await SaveFile(); }
/// <summary> /// Signs the specified x node. /// </summary> /// <param name="xNode">The x node.</param> /// <param name="rsa">The RSA.</param> /// <returns></returns> public static XmlNode Sign(XmlNode xNode, RSAService rsa) { return(Sign(xNode, rsa.Provider)); }
/// <summary> /// Signs the specified x element. /// </summary> /// <param name="xElement">The x element.</param> /// <param name="rsa">The RSA.</param> /// <returns></returns> public static XmlElement Sign(XmlElement xElement, RSAService rsa) { return(Sign(xElement, rsa.Provider)); }
public void TestReadPublicKeyFromPrivate_String() { Console.Out.WriteLine("readPublicKeyFromPrivate"); RSAService instance = new RSAService(keysize); RSAPublicKey result = instance.ReadPublicKeyFromPrivate(privateKeyfile); Assert.IsNotNull(result); }
public ACTokenManager(RSAService rsa) { _rsa = rsa; }
public void TestReadPublicKey_String() { Console.Out.WriteLine("readPublicKey"); RSAService instance = new RSAService(keysize); RSAPublicKey publicKey = instance.ReadPublicKey(publicKeyfile); Assert.IsNotNull(publicKey); }
/// <summary> /// Verifies the signature. /// </summary> /// <param name="xNode">The x node.</param> /// <param name="rsa">The RSA.</param> /// <returns></returns> public static bool VerifySignature(XmlNode xNode, RSAService rsa) { return(VerifySignature(xNode, rsa.Provider)); }
public FileSignModel() { User = new UserDto(); RSAService = new RSAService(); SymetricService = new SymetricService(); }
public static void Test() { Console.Out.WriteLine("Begin Example_010."); // Create some data to test with. Support.TestData(TESTDATA_FILE); /** * Create a public / private RSA key pair. */ RSAService rsa = new RSAService(); if (!rsa.AreKeysPresent(privateKeyfile, publicKeyfile)) { Console.Out.WriteLine("Begin Create RSA Keys."); using (FileStream os_private = new FileStream(privateKeyfile, FileMode.Create), os_public = new FileStream(publicKeyfile, FileMode.Create)) { rsa.GenerateKey(os_private, os_public); } Console.Out.WriteLine("End Create RSA Keys."); } /** * RSA keys are asynchronous; there is a public and private key. Each * key can only decrypt data encrypted with the other key. A client * process would not have both keys, this is only for demonstration * purposes. */ Console.Out.WriteLine("Begin Read RSA Keys."); RSAPrivateKey privateKey = null; RSAPublicKey publicKey = null; using (FileStream is_private = new FileStream(privateKeyfile, FileMode.Open), is_public = new FileStream(publicKeyfile, FileMode.Open)) { privateKey = rsa.ReadPrivateKey(is_private); publicKey = rsa.ReadPublicKey(is_public); } Console.Out.WriteLine("End Read RSA Keys."); /** * Use public key to encrypt a file stream directly to another file * stream. */ Console.Out.WriteLine("Begin Encrypt Data."); using (FileStream outstream = new FileStream(TESTDATA_ENC_FILE, FileMode.Create), instream = new FileStream(TESTDATA_FILE, FileMode.Open)) { rsa.Encode(instream, outstream, publicKey); } Console.Out.WriteLine("End Encrypt Data."); /** * Now decrypt the encrypted file using the private key. */ Console.Out.WriteLine("Begin Decrypt Data."); using (FileStream outstream = new FileStream(TESTDATA_DEC_FILE, FileMode.Create), instream = new FileStream(TESTDATA_ENC_FILE, FileMode.Open)) { rsa.Decode(instream, outstream, privateKey); } Console.Out.WriteLine("End Decrypt Data."); /** * Compare the original and decrypted files. */ string shaOriginal = DigestSHA.Sha256(new FileStream(TESTDATA_FILE, FileMode.Open)); string shaDecripted = DigestSHA.Sha256(new FileStream(TESTDATA_DEC_FILE, FileMode.Open)); if (Compare.SafeEquals(UTF8Encoding.UTF8.GetBytes(shaOriginal), UTF8Encoding.UTF8.GetBytes(shaDecripted))) { Console.Out.WriteLine("Encrypted and decrypted files are the same."); } else { Console.Out.WriteLine("Encrypted and decrypted files are NOT the same."); } Console.Out.WriteLine("End Example_010."); }
public static void Test() { Console.Out.WriteLine("Begin Example_020."); // Create some data to test with. Support.TestData(TESTDATA_FILE); /** * Create a public / private RS key pair. */ RSAService rsa = new RSAService(); if (!rsa.AreKeysPresent(privateKeyfile, publicKeyfile)) { Console.Out.WriteLine("Begin Create RSA Keys."); rsa.GenerateKey(privateKeyfile, publicKeyfile); Console.Out.WriteLine("End Create RSA Keys."); } /** * RSA keys are asynchronous; there is a public and private key. Each * key can only decrypt data encrypted with the other key. A client * process would not have both keys, this is only for demonstration * purposes. */ Console.Out.WriteLine("Begin Read RSA Keys."); RSAPrivateKey privateKey = rsa.ReadPrivateKey(privateKeyfile); RSAPublicKey publicKey = rsa.ReadPublicKey(publicKeyfile); Console.Out.WriteLine("End Read RSA Keys."); /** * Read the test data into a byte array. Be sure to use UTF-8 when * converting between strings and byte arrays. */ Console.Out.WriteLine("Begin Read Data."); string testdata = File.ReadAllText(TESTDATA_FILE); byte[] testdata_bytes = UTF8Encoding.UTF8.GetBytes(testdata); Console.Out.WriteLine("End Read Data."); /** * Use public key to encrypt a byte array to another byte array. */ Console.Out.WriteLine("Begin Encrypt Data."); byte[] testdata_enc = rsa.Encode(testdata_bytes, publicKey); Console.Out.WriteLine("End Encrypt Data."); /** * Now decrypt the encrypted file using the private key. */ Console.Out.WriteLine("Begin Decrypt Data."); byte[] testdata_dec = rsa.Decode(testdata_enc, privateKey); Console.Out.WriteLine("End Decrypt Data."); /** * Compare the original and decrypted files. */ String shaOriginal = DigestSHA.Sha256(testdata_bytes); String shaDecripted = DigestSHA.Sha256(testdata_dec); if (Compare.SafeEquals(UTF8Encoding.UTF8.GetBytes(shaOriginal), UTF8Encoding.UTF8.GetBytes(shaDecripted))) { Console.Out.WriteLine("Encrypted and decrypted files are the same."); } else { Console.Out.WriteLine("Encrypted and decrypted files are NOT the same."); } Console.Out.WriteLine("End Example_020."); }
public void TestEncodeAndDecode_3args() { Console.Out.WriteLine("encode and decode stream"); RSAService instance = new RSAService(keysize); RSAPrivateKey privateKey = instance.ReadPrivateKey(privateKeyfile); RSAPublicKey publicKey = instance.ReadPublicKey(publicKeyfile); byte[] decData; using (MemoryStream outstream = new MemoryStream()) { using (MemoryStream instream = new MemoryStream(msgBytes)) { instance.Encode(instream, outstream, privateKey); byte[] encData = outstream.ToArray(); decData = instance.Decode(encData, publicKey); } } Boolean bCompare = Compare.SafeEquals(msgBytes, decData); Assert.IsTrue(bCompare); using (MemoryStream outstream = new MemoryStream()) { using (MemoryStream instream = new MemoryStream(msgBytes)) { instance.Encode(instream, outstream, publicKey); byte[] encData = outstream.ToArray(); decData = instance.Decode(encData, privateKey); } } bCompare = Compare.SafeEquals(msgBytes, decData); Assert.IsTrue(bCompare); }
/// <summary> /// Signs the specified x document. /// </summary> /// <param name="xDoc">The x document.</param> /// <param name="rsa">The RSA.</param> /// <returns></returns> public static XmlDocument Sign(XmlDocument xDoc, RSAService rsa) { return(Sign(xDoc, rsa.Provider)); }
/// <summary> /// Verifies the signature. /// </summary> /// <param name="xElement">The x element.</param> /// <param name="rsa">The RSA.</param> /// <returns></returns> public static bool VerifySignature(XmlElement xElement, RSAService rsa) { return(VerifySignature(xElement, rsa.Provider)); }
public bool Verify(byte[] nis) { var digestAlgo = string.Empty; switch (OIDDSMessageDigestHashAlgo) { case "2.16.840.1.101.3.4.2.1": digestAlgo = "SHA256"; break; case "2.16.840.1.101.3.4.2.3": digestAlgo = "SHA512"; break; default: throw new Exception("hash algoritm not valid"); } /*Get hashed data of * - ID servizi * - Seriale carta * - Certificato utente * - Chiave pubblica di internal authentication * - Chiave pubblica di internal authentication per i servizi * contained in SignedDataObject and calculate hash of hash*/ var digestRecalculation = SignedDataObject.DeepChild(1, 0).Data.ToMessageDigest(digestAlgo); //Compare recalculation of hash with data contained in signer message digest object to verify equality if (digestRecalculation.ToHexString() != SignerMessageDigest.Data.ToHexString()) { return(false); // Digest SOD not correspond to data } //Get Document Signer public key from SignedCert data var dsPubKey = DSCertificate.DeepChild(0, 6, 1, 0); //Get modulus and exponent from Document Signer public key var dsModPubKey = dsPubKey.Child(0, 0x02).Data; // modulus. 0x02 Verify that result is a INTEGER var dsExpPubKey = dsPubKey.Child(1, 0x02).Data; // exp. 0x02 Verify that result is a INTEGER //Verify SOD sign using DS public key and sign algoritm using (var rsa = new RSAService(dsModPubKey, dsExpPubKey)) { var isValidSod = false; switch (OIDDSMessageDigestSignAlgo) { case "1.2.840.113549.1.1.5": isValidSod = rsa.CheckSHA1withRSAEncryption(Signature.Data, SignatureAlgoritmIdentifier.MakeTag(0x31)); break; case "1.2.840.113549.1.1.10": isValidSod = rsa.CheckRSASSAPSS(Signature.Data, SignatureAlgoritmIdentifier.MakeTag(0x31), digestAlgo); break; default: throw new Exception("Sign aloritm not supported"); } if (!isValidSod) { throw new Exception("SOD sign wrong"); //SOD sign wrong } } //Get issuer information from Document Signer certificate and compare it with data in IssuerName ASN1 tag var issuer = DSCertificate.DeepChild(0).Child(3, 0x30); //0x30 Verify that result is a SEQUENCE //Compare issuer information obtained from DS certificate with information stored directly in IssuerName tag if (issuer.Data.ToHexString() != IssuerName.Data.ToHexString()) { return(false); //Issuer name check failed } //Get serial number information from Document Signer certificate and compare it with data in SignerCertSerialNumber ASN1 tag var serialNumber = DSCertificate.DeepChild(0).Child(1, 0x02); //02 Verify that result is a INTEGER if (serialNumber.Data.ToHexString() != SerialNumber.Data.ToHexString()) { return(false); // Serial Number of certificate wrong } //Get hash of NIS and verify it with NIS stored in file system var dgsHash = SignedData.Child(2, 0x30); //0x30 Verify that result is a SEQUENCE var isValidNis = false; foreach (var dg in dgsHash.children) { /* * 0xa1 : IdServizi * 0xa2 : Seriale carta * 0xa3 : Certificato utente * 0xa4 : Chiave pubblica di Internal Authentication * 0xa5 : Chiave pubblica di Internal Authentication per i Servizi * 0x1b : Parametri DH */ var oID = dg.Child(0, 02); //02 Verify that result is a INTEGER if (oID.Data.ToHexString() == "a1") { //Get hashed NIS from DG var hashedNis = dg.Child(1, 04).Data; //04 Verify that result is a OCTECT STRING //Calculate hash of file nis and compare it with the other in dg if (hashedNis.ToHexString() == nis.ToMessageDigest(digestAlgo).ToHexString()) { isValidNis = true; } } } //TODO: Check that certificate is issued by https://csca-ita.interno.gov.it/index_ITA.htm (CSCA certificate) return(isValidNis); }
/// <summary> /// Verifies the signature. /// </summary> /// <param name="xDoc">The x document.</param> /// <param name="rsa">The RSA.</param> /// <returns></returns> public static bool VerifySignature(XmlDocument xDoc, RSAService rsa) { return(VerifySignature(xDoc, rsa.Provider)); }
public void TestReadPublicKeyFromPrivate_InputStream() { Console.Out.WriteLine("readPublicKeyFromPrivate"); RSAService instance = new RSAService(keysize); using (FileStream instream = new FileStream(privateKeyfile, FileMode.Open)) { RSAPublicKey result = instance.ReadPublicKeyFromPrivate(instream); Assert.IsNotNull(result); } }
private void button2_Click(object sender, EventArgs e) { if (string.IsNullOrWhiteSpace(input_d.Text)) { ShowErrorDoc2("Faltan Datos"); return; } ; if (string.IsNullOrWhiteSpace(input_dp.Text)) { ShowErrorDoc2("Faltan Datos"); return; } ; if (string.IsNullOrWhiteSpace(input_dq.Text)) { ShowErrorDoc2("Faltan Datos"); return; } ; if (string.IsNullOrWhiteSpace(input_exponent.Text)) { ShowErrorDoc2("Faltan Datos"); return; } ; if (string.IsNullOrWhiteSpace(input_inverseq.Text)) { ShowErrorDoc2("Faltan Datos"); return; } ; if (string.IsNullOrWhiteSpace(input_modulus.Text)) { ShowErrorDoc2("Faltan Datos"); return; } ; if (string.IsNullOrWhiteSpace(input_p.Text)) { ShowErrorDoc2("Faltan Datos"); return; } ; if (string.IsNullOrWhiteSpace(input_q.Text)) { ShowErrorDoc2("Faltan Datos"); return; } ; RSAParameters P; try { P = new RSAParameters() { D = Convert.FromBase64String(input_d.Text), DP = Convert.FromBase64String(input_dp.Text), DQ = Convert.FromBase64String(input_dq.Text), Exponent = Convert.FromBase64String(input_exponent.Text), InverseQ = Convert.FromBase64String(input_inverseq.Text), Modulus = Convert.FromBase64String(input_modulus.Text), P = Convert.FromBase64String(input_p.Text), Q = Convert.FromBase64String(input_q.Text) }; } catch (Exception) { ShowErrorDoc2("Datos Incorrectos"); return; } if (!string.IsNullOrWhiteSpace(input_criptedFrase1.Text)) { var r = RSAService.Decrypt(input_criptedFrase1.Text, P); if (r != null) { output_Frase1.Text = new SICLib.Manager.StringBuilder(r).RemoveAsciiControllChars().GetString(); } else { output_Frase1.Text = "Error"; } } else { output_Frase1.Text = "NULL"; } if (!string.IsNullOrWhiteSpace(input_criptedFrase2.Text)) { var r = RSAService.Decrypt(input_criptedFrase2.Text, P); if (r != null) { output_Frase2.Text = new SICLib.Manager.StringBuilder(r).RemoveAsciiControllChars().GetString(); } else { output_Frase2.Text = "Error"; } } else { output_Frase2.Text = "NULL"; } if (!string.IsNullOrWhiteSpace(input_criptedFrase3.Text)) { var r = RSAService.Decrypt(input_criptedFrase3.Text, P); if (r != null) { output_Frase3.Text = new SICLib.Manager.StringBuilder(r).RemoveNoneAlphanumericChars().GetString(); } else { output_Frase3.Text = "Error"; } } else { output_Frase3.Text = "NULL"; } }
public MockAcTokenValidator(RSAService rsa) : base(rsa) { }
public FileVerifySignatureModel() { XmlService = new XmlService(); RSAService = new RSAService(); }
public object Verify([FromBody] TokenModel tokens) { RSAService.rsa(); return(authService.GetData(tokens.AccessToken)); }