public static string EncryptPassword(string _password) { Chilkat.Crypt2 _encrypt = new Chilkat.Crypt2(); bool isUnlocked = _encrypt.UnlockComponent("SCOTTGCrypt_FdXsYk2WWPjN"); string password; password = "******"; _encrypt.CryptAlgorithm = "aes"; _encrypt.CipherMode = "cbc"; _encrypt.KeyLength = 128; // Generate a binary secret key from a password string // of any length. For 128-bit encryption, GenEncodedSecretKey // generates the MD5 hash of the password and returns it // in the encoded form requested. The 2nd param can be // "hex", "base64", "url", "quoted-printable", etc. string hexKey; hexKey = _encrypt.GenEncodedSecretKey(password, "hex"); _encrypt.SetEncodedKey(hexKey, "hex"); _encrypt.EncodingMode = "base64"; // Encrypt a string and return the binary encrypted data // in a base-64 encoded string. string s1 = _encrypt.DecryptStringENC(_password); return _encrypt.EncryptStringENC(_password); }
/// <summary> /// verifica la firma ed estrae il file originale /// </summary> /// <param name="pathFileSign">documento firmato</param> /// <param name="pathFile">path e nome file</param> /// <param name="lastError">ultimo errore nella funzionalità</param> /// <returns>verifica e estrazione avvenuta con successo</returns> /// <example> /// string pathFileOut = "c:\file\test.xml" /// Utilities.VerificaEstraiFirma(@"c:\temp\IT01234567890_FPA01.xml.p7m", pathFileOut, ref lastError)) /// /// c:\file\test.xml file estratto /// /// </example> public static bool VerificaEstraiFirma(string pathFileSign, string pathFile, ref string lastError) { bool success = false; try { if (Utilities.glob.UnlockStatus == 0) { lastError = "Licenza bloccata"; return(success); } Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); // Verify and restore the original file: success = crypt.VerifyP7M(pathFileSign, pathFile); if (!success) { lastError = crypt.LastErrorText; return(success); } success = true; } catch { throw; } return(success); }
private void button2_Click(object sender, EventArgs e) { string ivHex = textBox2.Text; // The secret key must equal the size of the key. For // 256-bit encryption, the binary secret key is 32 bytes. // For 128-bit encryption, the binary secret key is 16 bytes. string keyHex = textBox1.Text; // Encrypt a string... // The input string is 44 ANSI characters (i.e. 44 bytes), so // the output should be 48 bytes (a multiple of 16). // Because the output is a hex string, it should // be 96 characters long (2 chars per byte). Chilkat.Crypt2 decrypt = new Chilkat.Crypt2(); decrypt.CryptAlgorithm = "aes"; decrypt.CipherMode = "ctr"; decrypt.KeyLength = 256; decrypt.EncodingMode = "base64"; decrypt.SetEncodedIV(ivHex, "ascii"); decrypt.SetEncodedKey(keyHex, "ascii"); // Now decrypt: string decStr = decrypt.DecryptStringENC(richTextBox1.Text); richTextBox2.Text = decStr; }
private void loginWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); crypt.UnlockComponent("Crypt!TEAM!BEAN_34F4144DpR6G"); crypt.CryptAlgorithm = "aes"; crypt.CipherMode = "cbc"; crypt.KeyLength = 128; crypt.SecretKey = crypt.GenerateSecretKey(txtUser.Text); crypt.EncodingMode = "base64"; if (e.Error != null) { MessageBox.Show(e.Error.Message); } if (frmStatusBar != null) { frmStatusBar.Close(); } if (Kalibrasi.global_variable.global.gcPASSWORD == crypt.EncryptStringENC(txtPassword.Text)) { this.Close(); } else { Kalibrasi.global_variable.global.gcUSERID = lcUserId; } }
public string algoritmoHash(byte[] pArchivo, string algorithm) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); bool succes = crypt.UnlockComponent("Anything for 30-day trial"); if (succes != true) { Console.WriteLine(crypt.LastErrorText); return(""); } // Set the name of the hash algorithm. // Other choices include "sha1", "sha256", "sha384", "sha512", "md2", "md5", and "haval". crypt.HashAlgorithm = algorithm; // EncodingMode specifies the encoding of the hash output. // It may be "hex", "url", "base64", or "quoted-printable". crypt.EncodingMode = "hex"; // Files of any type may be hashed -- it doesn't matter // if the file is binary or text... string hashStr; hashStr = crypt.HashBytesENC(pArchivo); if (crypt.LastMethodSuccess != true) { Console.WriteLine(crypt.LastErrorText); return(""); } Console.WriteLine(hashStr); return(hashStr); }
public static void performPoly1305MAC(string text) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); bool success = crypt.UnlockComponent("Anything for 30-day trial"); if (success != true) { Console.WriteLine(crypt.LastErrorText); return; } // Set the MAC algorithm to poly1305 crypt.MacAlgorithm = "poly1305"; // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // Valid modes are (case insensitive) "Base64", "modBase64", "Base32", "Base58", "UU", // "QP" (for quoted-printable), "URL" (for url-encoding), "Hex", // "Q", "B", "url_oauth", "url_rfc1738", "url_rfc2396", and "url_rfc3986". crypt.EncodingMode = "hex"; // Poly1305 always uses a 32-byte (256-bit) MAC key. string keyHex = "1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0"; success = crypt.SetMacKeyEncoded(keyHex, "hex"); string plainText = "'Twas brillig, and the slithy toves\nDid gyre and gimble in the wabe:\nAll mimsy were the borogoves,\nAnd the mome raths outgrabe."; // The computed tag should match the Tag shown below. // (Note: hexidecimal encoding is case insensitive.) string encTag = crypt.MacStringENC(text); //Console.WriteLine(encTag); }
public static void perform3DES(string text) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); bool success = crypt.UnlockComponent("Anything for 30-day trial"); if (success != true) { Console.WriteLine(crypt.LastErrorText); return; } // Specify 3DES for the encryption algorithm: crypt.CryptAlgorithm = "3des"; // CipherMode may be "ecb" or "cbc" crypt.CipherMode = "cbc"; // KeyLength must be 192. 3DES is technically 168-bits; // the most-significant bit of each key byte is a parity bit, // so we must indicate a KeyLength of 192, which includes // the parity bits. crypt.KeyLength = 192; // The padding scheme determines the contents of the bytes // that are added to pad the result to a multiple of the // encryption algorithm's block size. 3DES has a block // size of 8 bytes, so encrypted output is always // a multiple of 8. crypt.PaddingScheme = 0; // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", or "quoted-printable". crypt.EncodingMode = "hex"; // An initialization vector is required if using CBC or CFB modes. // ECB mode does not use an IV. // The length of the IV is equal to the algorithm's block size. // It is NOT equal to the length of the key. string ivHex = "0001020304050607"; crypt.SetEncodedIV(ivHex, "hex"); // The secret key must equal the size of the key. For // 3DES, the key must be 24 bytes (i.e. 192-bits). string keyHex = "000102030405060708090A0B0C0D0E0F0001020304050607"; crypt.SetEncodedKey(keyHex, "hex"); string encStr = crypt.EncryptStringENC(text); //Console.WriteLine(encStr); // Now decrypt: string decStr = crypt.DecryptStringENC(encStr); // Console.WriteLine(decStr); }
public static void performChaChaEncryption(string text) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); // Set the encryption algorithm to chacha20 // chacha20 is a stream cipher, and therefore no cipher mode applies. // Set the encryption algorithm to chacha20 // chacha20 is a stream cipher, and therefore no cipher mode applies. crypt.CryptAlgorithm = "chacha20"; // The key length for chacha20 is always 256-bits. crypt.KeyLength = 256; // Note: "padding" only applies to block encryption algorithmns. // Since chacha20 is a stream cipher, there is no padding and the output // number of bytes is exactly equal to the input. // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // Valid modes are (case insensitive) "Base64", "modBase64", "Base32", "Base58", "UU", // "QP" (for quoted-printable), "URL" (for url-encoding), "Hex", // "Q", "B", "url_oauth", "url_rfc1738", "url_rfc2396", and "url_rfc3986". crypt.EncodingMode = "hex"; // The inputs to ChaCha20 encryption, specified by RFC 7539, are: // 1) A 256-bit secret key. // 2) A 96-bit nonce. // 3) A 32-bit initial count. // The IV property is used to specify the chacha20 nonce. // For a 96-bit nonce, the IV should be 12 bytes in length. // // Note: Some implementations of chacha20, such as that used internally by SSH, // use a 64-bit nonce and 64-bit count. To do chacha20 encryption in this way, // simply provide 8 bytes for the IV instead of 12 bytes. Chilkat will then automatically // use 8 bytes (64-bits) for the count. // This example duplicates Test Vector #3 (for ChaCha20 encryption) from RFC 7539. string ivHex = "000000000000000000000002"; crypt.SetEncodedIV(ivHex, "hex"); crypt.InitialCount = 42; string keyHex = "1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0"; crypt.SetEncodedKey(keyHex, "hex"); // string plainText = "'Twas brillig, and the slithy toves\nDid gyre and gimble in the wabe:\nAll mimsy were the borogoves,\nAnd the mome raths outgrabe."; string encStr = crypt.EncryptStringENC(text); //Console.WriteLine(encStr); //Console.WriteLine("I am wor"); // Now decrypt: string decStr = crypt.DecryptStringENC(encStr); //Console.WriteLine(decStr); }
public string HashContent(string content) { var crypt = new Chilkat.Crypt2 { HashAlgorithm = "sha256" }; var hash = crypt.HashStringENC(content); return(hash); }
public string HashContent <T>(T content) { var crypt = new Chilkat.Crypt2 { HashAlgorithm = "sha256" }; var serializedContent = JsonConvert.SerializeObject(content); var hash = crypt.HashStringENC(serializedContent); return(hash); }
public static void performBlowfish2(string text) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); // Attention: use "blowfish2" for the algorithm name: crypt.CryptAlgorithm = "blowfish2"; // CipherMode may be "ecb", "cbc", or "cfb" crypt.CipherMode = "cbc"; // KeyLength (in bits) may be a number between 32 and 448. // 128-bits is usually sufficient. The KeyLength must be a // multiple of 8. crypt.KeyLength = 128; // The padding scheme determines the contents of the bytes // that are added to pad the result to a multiple of the // encryption algorithm's block size. Blowfish has a block // size of 8 bytes, so encrypted output is always // a multiple of 8. crypt.PaddingScheme = 0; // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", or "quoted-printable". crypt.EncodingMode = "hex"; // An initialization vector is required if using CBC or CFB modes. // ECB mode does not use an IV. // The length of the IV is equal to the algorithm's block size. // It is NOT equal to the length of the key. string ivHex = "0001020304050607"; crypt.SetEncodedIV(ivHex, "hex"); // The secret key must equal the size of the key. For // 256-bit encryption, the binary secret key is 32 bytes. // For 128-bit encryption, the binary secret key is 16 bytes. string keyHex = "000102030405060708090A0B0C0D0E0F"; crypt.SetEncodedKey(keyHex, "hex"); // Encrypt a string... // The input string is 44 ANSI characters (i.e. 44 bytes), so // the output should be 48 bytes (a multiple of 8). // Because the output is a hex string, it should // be 96 characters long (2 chars per byte). string encStr = crypt.EncryptStringENC(text); //Console.WriteLine(encStr); // Now decrypt: string decStr = crypt.DecryptStringENC(encStr); //Console.WriteLine(decStr); }
public static void performTwoFish(string text) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); // Set the encryption algorithm = "twofish" crypt.CryptAlgorithm = "twofish"; // CipherMode may be "ecb" or "cbc" crypt.CipherMode = "cbc"; // KeyLength may be 128, 192, 256 crypt.KeyLength = 256; // The padding scheme determines the contents of the bytes // that are added to pad the result to a multiple of the // encryption algorithm's block size. Twofish has a block // size of 16 bytes, so encrypted output is always // a multiple of 16. crypt.PaddingScheme = 0; // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", or "quoted-printable". crypt.EncodingMode = "hex"; // An initialization vector is required if using CBC mode. // ECB mode does not use an IV. // The length of the IV is equal to the algorithm's block size. // It is NOT equal to the length of the key. string ivHex = "000102030405060708090A0B0C0D0E0F"; crypt.SetEncodedIV(ivHex, "hex"); // The secret key must equal the size of the key. For // 256-bit encryption, the binary secret key is 32 bytes. // For 128-bit encryption, the binary secret key is 16 bytes. string keyHex = "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"; crypt.SetEncodedKey(keyHex, "hex"); // Encrypt a string... // The input string is 44 ANSI characters (i.e. 44 bytes), so // the output should be 48 bytes (a multiple of 16). // Because the output is a hex string, it should // be 96 characters long (2 chars per byte). string encStr = crypt.EncryptStringENC(text); // Console.WriteLine(encStr); // Now decrypt: string decStr = crypt.DecryptStringENC(encStr); // Console.WriteLine(decStr); }
private Chilkat.Crypt2 m_encoder = null; // We'll use this for encoding/decoding public Form1() { InitializeComponent(); Chilkat.Global glob = new Chilkat.Global(); if (!glob.UnlockBundle("Anything for 30-day trial")) { MessageBox.Show("Failed to unlock Chilkat."); } m_prng = new Chilkat.Prng(); m_encoder = new Chilkat.Crypt2(); }
/// <summary> /// 登录密码加密 /// </summary> /// <param name="password">登录密码</param> /// <param name="encryptType">加密方式</param> /// <returns></returns> public static string GetPasswordMD5Value(string password, string encryptType = "") { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); if (encryptType == "m") { crypt.HashAlgorithm = "md5"; crypt.EncodingMode = "base64"; crypt.Charset = "Unicode"; } return(crypt.HashStringENC(str: password)); }
private void button1_Click(object sender, EventArgs e) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); // AES is also known as Rijndael. crypt.CryptAlgorithm = "aes"; // CipherMode may be "ctr", "cfb", "ecb" or "cbc" crypt.CipherMode = "ctr"; // KeyLength may be 128, 192, 256 crypt.KeyLength = 256; // Counter mode emits the exact number of bytes input, and therefore // padding is not used. The PaddingScheme property does not apply with CTR mode. // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", "quoted-printable", or many other choices. crypt.EncodingMode = "base64"; // An initialization vector (nonce) is required if using CTR mode. // The length of the IV is equal to the algorithm's block size. // It is NOT equal to the length of the key. string ivHex = textBox2.Text; crypt.SetEncodedIV(ivHex, "ascii"); // The secret key must equal the size of the key. For // 256-bit encryption, the binary secret key is 32 bytes. // For 128-bit encryption, the binary secret key is 16 bytes. string keyHex = textBox1.Text; crypt.SetEncodedKey(keyHex, "ascii"); // Encrypt a string... // The input string is 44 ANSI characters (i.e. 44 bytes), so // the output should be 48 bytes (a multiple of 16). // Because the output is a hex string, it should // be 96 characters long (2 chars per byte). string encStr = crypt.EncryptStringENC(richTextBox2.Text); //Debug.WriteLine(encStr); richTextBox1.Text = encStr; }
private void cmdOK_Click(object sender, EventArgs e) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); crypt.UnlockComponent("Crypt!TEAM!BEAN_34F4144DpR6G"); crypt.CryptAlgorithm = "aes"; crypt.CipherMode = "cbc"; crypt.KeyLength = 128; crypt.SecretKey = crypt.GenerateSecretKey(txtUser.Text); crypt.EncodingMode = "base64"; lcUserId = Kalibrasi.global_variable.global.gcUSERID; Kalibrasi.global_variable.global.gcUSERID = txtUser.Text; frmStatusBar = new frmStatusBar(); frmStatusBar.Show(); frmStatusBar.CancelButtonClicked += new CancelButtonEventHandler(frmStatusBar_CancelButtonClicked); loginWorker.RunWorkerAsync(); }
public static void performARC4(string text) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); // Set the encryption algorithm = "arc4" crypt.CryptAlgorithm = "arc4"; // KeyLength may range from 1 byte to 256 bytes. // (i.e. 8 bits to 2048 bits) // ARC4 key sizes are typically in the range of // 40 to 128 bits. // The KeyLength property is specified in bits: crypt.KeyLength = 128; // Note: The PaddingScheme and CipherMode properties // do not apply w/ ARC4. ARC4 does not encrypt in blocks -- // it is a streaming encryption algorithm. The number of output bytes // is exactly equal to the number of input bytes. // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", or "quoted-printable". crypt.EncodingMode = "hex"; // Note: ARC4 does not utilize initialization vectors. IV's only // apply to block encryption algorithms. // The secret key must equal the size of the key. // For 128-bit encryption, the binary secret key is 16 bytes. string keyHex = "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"; crypt.SetEncodedKey(keyHex, "hex"); // Encrypt a string... // The output length is exactly equal to the input. In this // example, the input string is 44 chars (ANSI bytes) so the // output is 44 bytes -- and when hex encoded results in an // 88-char string (2 chars per byte for the hex encoding). string encStr = crypt.EncryptStringENC(text); //Console.WriteLine(encStr); // Now decrypt: string decStr = crypt.DecryptStringENC(encStr); //Console.WriteLine(decStr); }
public string Operation(CryptoRequest req, bool isDecryption) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2 { CryptAlgorithm = "aes", CipherMode = "cbc", KeyLength = 256, PaddingScheme = 0, EncodingMode = "hex" }; var data = Convert.FromBase64String(req.Data64); crypt.SetSecretKeyViaPassword(req.Password); var operated = isDecryption ? crypt.DecryptBytes(data) : crypt.EncryptBytes(data); return(Convert.ToBase64String(operated)); }
/// <summary> /// verifica la firma /// </summary> /// <param name="pathFileSign">documento firmato</param> /// <param name="lastError">ultimo errore nella funzionalità</param> /// <returns>se true la verifica è avvenuta con successo</returns> public static bool VerificaFirma(string pathFileSign, ref string lastError) { bool success = false; try { if (Utilities.glob.UnlockStatus == 0) { lastError = "Licenza bloccata"; return(success); } Chilkat.BinData bd = new Chilkat.BinData(); success = bd.LoadFile(pathFileSign); if (!success) { lastError = "Errore a caricare il file"; return(success); } Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); // Verifica ed estrae il payload contenuto nel .p7m. success = crypt.OpaqueVerifyBd(bd); if (!success) { lastError = crypt.LastErrorText; return(success); } success = true; } catch { throw; } return(success); }
private void button_Click(object sender, RoutedEventArgs e) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); if (!checkUnlocked()) { return; } crypt.CryptAlgorithm = "chacha20"; // The key length for chacha20 is always 256-bits. crypt.KeyLength = 256; crypt.EncodingMode = "hex"; string ivHex = "000000000000000000000002"; crypt.SetEncodedIV(ivHex, "hex"); crypt.InitialCount = 42; string keyHex = "1c9240a5eb55d38af333888604f6b5f0473917c1402b80099dca5cbc207075c0"; crypt.SetEncodedKey(keyHex, "hex"); string plainText = textBox.Text; string encStr = crypt.EncryptStringENC(plainText); Debug.WriteLine(encStr); textBox1.Text = encStr; // Now decrypt: string decStr = crypt.DecryptStringENC(encStr); Debug.WriteLine(decStr); }
/// <summary> /// calcolo hash di un file /// </summary> /// <param name="pathFile">path and file</param> /// <param name="lastError">ultimo errore nella funzionalità</param> /// <param name="algorithm">algoritmo da utilizzare</param> /// <param name="encode">encode</param> /// <returns>hash del file</returns> public static string HashFile(string pathFile, ref string lastError, string algorithm = "sha256", string encode = "base64") { string hash = null; try { if (Utilities.glob.UnlockStatus == 0) { lastError = "Licenza bloccata"; return(hash); } Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); crypt.HashAlgorithm = algorithm; crypt.EncodingMode = encode; hash = crypt.HashFileENC(pathFile); } catch { throw; } return(hash); }
/// <summary> /// applica la marca temporale al file /// </summary> /// <param name="pathFileSign">file firmato</param> /// <param name="tsaUrl">url TSA</param> /// <param name="pathFileTimeStamped">file tsr da TSA</param> /// <param name="lastError">ultimo errore nella funzionalità</param> /// <param name="userName">user TSA (opzionale)</param> /// <param name="password">password TSA (opzionale)</param> /// <returns>true se la funzionalità ha avuto successo</returns> /// <example> /// if (Utilities.MarcaTemporale(@"c:\temp\IT01234567890_FPA01.xml.p7m", "https://freetsa.org/tsr", out pathFileTimeStamped, ref lastError, "myUser", "myPassword")) /// { /// pathFileTimeStamped -> c:\temp\IT01234567890_FPA01.xml.p7m.tsr /// } /// </example> public static bool MarcaTemporale(string pathFileSign, string tsaUrl, out string pathFileTimeStamped, ref string lastError, string userName = null, string password = null) { bool success = false; pathFileTimeStamped = null; try { string fileName = Path.GetFileName(pathFileSign); if (Utilities.glob.UnlockStatus == 0) { lastError = "Licenza bloccata"; return(success); } Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); crypt.HashAlgorithm = "sha256"; crypt.EncodingMode = "base64"; string base64Hash = crypt.HashFileENC(pathFileSign); Chilkat.Http http = new Chilkat.Http(); Chilkat.BinData requestToken = new Chilkat.BinData(); string optionalPolicyOid = string.Empty; bool addNonce = false; bool requestTsaCert = false; if (!string.IsNullOrWhiteSpace(userName) && !string.IsNullOrWhiteSpace(password)) { http.Login = userName; http.Password = password; http.BasicAuth = true; } // Create a time-stamp request token success = http.CreateTimestampRequest("sha256", base64Hash, optionalPolicyOid, addNonce, requestTsaCert, requestToken); if (!success) { lastError = http.LastErrorText; return(success); } Chilkat.HttpResponse resp = http.PBinaryBd("POST", tsaUrl, requestToken, "application/timestamp-query", false, false); if (!http.LastMethodSuccess) { lastError = http.LastErrorText; return(success); } Chilkat.BinData timestampReply = new Chilkat.BinData(); resp.GetBodyBd(timestampReply); if (!timestampReply.LastMethodSuccess) { return(success); } string s = Path.ChangeExtension(fileName, $".{Enum.GetName(typeof(EstensioniFile), EstensioniFile.tsr)}"); success = timestampReply.WriteFile(s); if (success) { pathFileTimeStamped = s; } } catch { throw; } return(success); }
/// <summary> /// Firma del file /// </summary> /// <param name="SubjectCN">Subject Common Name</param> /// <param name="pathFile">file da firmare</param> /// <param name="lastError">ultimo errore nella funzionalità</param> /// <param name="pin">pin smartcard/usb (opzionale). Se non fornito comparirà una finestra di dialogo del sistema operativo Windows per indicare il pin</param> /// <param name="csp">provider csp (opzionale). Se non indicato verrà selezionato automaticamente. Utilizzare questo parametro per indicarne uno specifico. Utilizzare il metodo CSPs per visualizza i csp presenti nel sistema</param> /// <returns>firma avvenuta con successo</returns> public static bool Firma(string SubjectCN, string pathFile, ref string lastError, string pin = null, string csp = null) { bool success = false; try { if (Utilities.glob.UnlockStatus == 0) { lastError = "Licenza bloccata"; return(success); } Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); // Utilizza il certificato su una smartcard o su USB. Chilkat.Cert cert = new Chilkat.Cert(); // cryptographic service provider if (!string.IsNullOrWhiteSpace(csp)) { success = cert.LoadFromSmartcard(csp); if (success != true) { lastError = cert.LastErrorText; return(success); } } // Passa il Subject CN del certificato al metodo LoadByCommonName. success = cert.LoadByCommonName(SubjectCN); if (success != true) { lastError = cert.LastErrorText; return(success); } // Fornire il PIN della smartcard. // Se il pin non è fornito esplicitamente qui, // Se non fornito dovrebbe comparire una finestra di dialogo del sistema operativo Windows per indicare il pin if (!string.IsNullOrWhiteSpace(pin)) { cert.SmartCardPin = pin; } // Fornisce il certificato per firmarlo success = crypt.SetSigningCert(cert); if (success != true) { lastError = crypt.LastErrorText; return(success); } // Indica l'algoritmo da utilizzare crypt.HashAlgorithm = "sha256"; // Specifico gli attributi firmati per essere inclusi. // (Questo è quello che fa un CAdES-BES compliant.) Chilkat.JsonObject jsonSignedAttrs = new Chilkat.JsonObject(); jsonSignedAttrs.UpdateInt("contentType", 1); jsonSignedAttrs.UpdateInt("signingTime", 1); jsonSignedAttrs.UpdateInt("messageDigest", 1); jsonSignedAttrs.UpdateInt("signingCertificateV2", 1); crypt.SigningAttributes = jsonSignedAttrs.Emit(); string sigFile = $"{pathFile}.{Enum.GetName(typeof(EstensioniFile), EstensioniFile.p7m)}"; // Creo una firma CAdES-BES, che contiene i dati originali success = crypt.CreateP7M(pathFile, sigFile); if (!success) { lastError = crypt.LastErrorText; return(success); } success = true; } catch { throw; } return(success); }
public static void performDeffieHelman(string text) { // Create two separate instances of the DH object. Chilkat.Dh dhBob = new Chilkat.Dh(); Chilkat.Dh dhAlice = new Chilkat.Dh(); // The DH algorithm begins with a large prime, P, and a generator, G. // These don't have to be secret, and they may be transmitted over an insecure channel. // The generator is a small integer and typically has the value 2 or 5. // The Chilkat DH component provides the ability to use known // "safe" primes, as well as a method to generate new safe primes. // This example will use a known safe prime. Generating // new safe primes is a time-consuming CPU intensive task // and is normally done offline. // Bob will choose to use the 2nd of our 8 pre-chosen safe primes. // It is the Prime for the 2nd Oakley Group (RFC 2409) -- // 1024-bit MODP Group. Generator is 2. // The prime is: 2^1024 - 2^960 - 1 + 2^64 * { [2^894 pi] + 129093 } dhBob.UseKnownPrime(2); // The computed shared secret will be equal to the size of the prime (in bits). // In this case the prime is 1024 bits, so the shared secret will be 128 bytes (128 * 8 = 1024). // However, the result is returned as an SSH1-encoded bignum in hex string format. // The SSH1-encoding prepends a 2-byte count, so the result is going to be 2 bytes // longer: 130 bytes. This results in a hex string that is 260 characters long (two chars // per byte for the hex encoding). string p; int g; // Bob will now send P and G to Alice. p = dhBob.P; g = dhBob.G; // Alice calls SetPG to set P and G. SetPG checks // the values to make sure it's a safe prime and will // return false if not. // Each side begins by generating an "E" // value. The CreateE method has one argument: numBits. // It should be set to twice the size of the number of bits // in the session key. // Let's say we want to generate a 128-bit session key // for AES encryption. The shared secret generated by the Diffie-Hellman // algorithm will be longer, so we'll hash the result to arrive at the // desired session key length. However, the length of the session // key we'll utlimately produce determines the value that should be // passed to the CreateE method. // In this case, we'll be creating a 128-bit session key, so pass 256 to CreateE. // This setting is for security purposes only -- the value // passed to CreateE does not change the length of the shared secret // that is produced by Diffie-Hellman. // Also, there is no need to pass in a value larger // than 2 times the expected session key length. It suffices to // pass exactly 2 times the session key length. // Bob generates a random E (which has the mathematical // properties required for DH). string eBob; eBob = dhBob.CreateE(256); // Alice does the same: string eAlice; eAlice = dhAlice.CreateE(256); // The "E" values are sent over the insecure channel. // Bob sends his "E" to Alice, and Alice sends her "E" to Bob. // Each side computes the shared secret by calling FindK. // "K" is the shared-secret. string kBob; string kAlice; // Bob computes the shared secret from Alice's "E": kBob = dhBob.FindK(eAlice); // Alice computes the shared secret from Bob's "E": kAlice = dhAlice.FindK(eBob); // Amazingly, kBob and kAlice are identical and the expected // length (260 characters). The strings contain the hex encoded bytes of // our shared secret: // Console.WriteLine("Bob's shared secret:"); // Console.WriteLine(kBob); // Console.WriteLine("Alice's shared secret (should be equal to Bob's)"); // Console.WriteLine(kAlice); // To arrive at a 128-bit session key for AES encryption, Bob and Alice should // both transform the raw shared secret using a hash algorithm that produces // the size of session key desired. MD5 produces a 16-byte (128-bit) result, so // this is a good choice for 128-bit AES. // Here's how you would use Chilkat Crypt (a separate Chilkat component) to // produce the session key: Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); crypt.EncodingMode = "hex"; crypt.HashAlgorithm = "md5"; string sessionKey; sessionKey = crypt.HashStringENC(kBob); // Console.WriteLine("128-bit Session Key:"); // Console.WriteLine(sessionKey); // Encrypt something... crypt.CryptAlgorithm = "aes"; crypt.KeyLength = 128; crypt.CipherMode = "cbc"; // Use an IV that is the MD5 hash of the session key... string iv; iv = crypt.HashStringENC(sessionKey); // AES uses a 16-byte IV: //Console.WriteLine("Initialization Vector:"); //Console.WriteLine(iv); crypt.SetEncodedKey(sessionKey, "hex"); crypt.SetEncodedIV(iv, "hex"); // Encrypt some text: string cipherText64; crypt.EncodingMode = "base64"; cipherText64 = crypt.EncryptStringENC(text); //Console.WriteLine(cipherText64); string plainText; plainText = crypt.DecryptStringENC(cipherText64); //Console.WriteLine(plainText); }
private void EncDecButton_Click(object sender, EventArgs e) { try{ if (StringTextEditor.Text != "" && SecretKeyTextBox.Text != "") { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); // AES crypt.CryptAlgorithm = "aes"; // CipherMode may be "ecb", "cbc", "ofb", "cfb", "gcm", etc. // Note: Check the online reference documentation to see the Chilkat versions // when certain cipher modes were introduced. crypt.CipherMode = cipherModeMenu.Text; // KeyLength may be 128, 192, 256 crypt.KeyLength = Convert.ToInt32(keyLengthDropDownList.Text); // The padding scheme determines the contents of the bytes // that are added to pad the result to a multiple of the // encryption algorithm's block size. AES has a block // size of 16 bytes, so encrypted output is always // a multiple of 16. crypt.PaddingScheme = 0; // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", or "quoted-printable". crypt.EncodingMode = encodingModeDropDownList.Text; // An initialization vector is required if using CBC mode. // ECB mode does not use an IV. // The length of the IV is equal to the algorithm's block size. // It is NOT equal to the length of the key. string ivHex = "000102030405060708090A0B0C0D0E0F"; crypt.SetEncodedIV(ivHex, "hex"); string keyHex = crypt.HashStringENC(SecretKeyTextBox.Text); // The secret key must equal the size of the key. For // 256-bit encryption, the binary secret key is 32 bytes. // For 128-bit encryption, the binary secret key is 16 bytes. // string keyHex = "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"; crypt.SetEncodedKey(keyHex, "hex"); crypt.Charset = "utf-8"; string encStr = ""; string decStr = ""; if (EncryptToggleSwitch.Value == true) { // Encrypt radProgressBar1.Value2 = 0; encStr = crypt.EncryptStringENC(StringTextEditor.Text); ResultTextEditor.Text = encStr; radProgressBar1.Value2 = 100; this.radDesktopAlert1.CaptionText = "Abdal AES Encryption"; this.radDesktopAlert1.ContentText = "Encryption has been successful."; this.radDesktopAlert1.Show(); } else { // Now decrypt: radProgressBar1.Value2 = 0; decStr = crypt.DecryptStringENC(StringTextEditor.Text); ResultTextEditor.Text = decStr; radProgressBar1.Value2 = 100; this.radDesktopAlert1.CaptionText = "Abdal AES Encryption"; this.radDesktopAlert1.ContentText = "Decryption has been successful."; this.radDesktopAlert1.Show(); } } else { MessageBox.Show("The String and Secret Password fields must be filled"); } } catch (Exception error) { MessageBox.Show(error.Message); } }
public static void performAESGCM(string text) { Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); bool success = crypt.UnlockComponent("Anything for 30-day trial"); if (success != true) { Console.WriteLine(crypt.LastErrorText); return; } // Set the encryption algorithm to "AES" crypt.CryptAlgorithm = "aes"; // Indicate that the Galois/Counter Mode (GCM) should be used: crypt.CipherMode = "gcm"; // KeyLength may be 128, 192, 256 crypt.KeyLength = 128; // This is the 128-bit AES secret key (in hex format) string K = "feffe9928665731c6d6a8f9467308308"; // This is the 16-byte initialization vector: string IV = "cafebabefacedbaddecaf888"; // This is the additional data to be used as input to the GCM AEAD algorithm, // but is not included in the output. It plays a role in the computation of the // resulting authenticated tag. string AAD = "feedfacedeadbeeffeedfacedeadbeefabaddad2"; // The plain-text bytes (in hex format) to be encrypted. string PT = "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532fcf0e2449a6b525b16aedf5aa0de657ba637b39"; PT = text; // The expected cipher text (in hex format) string CT = "42831ec2217774244b7221b784d0d49ce3aa212f2c02a4e035c17e2329aca12e21d514b25466931c7d8f6a5aac84aa051ba30b396a0aac973d58e091"; // The expected authenticated tag given the above inputs. string T = "5bc94fbc3221a5db94fae95ae7121a47"; // Note: The above data are the values for test vector #4 from // the PDF document at: http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-spec.pdf // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", or "quoted-printable". crypt.EncodingMode = "hex"; // Set the secret key and IV crypt.SetEncodedIV(IV, "hex"); crypt.SetEncodedKey(K, "hex"); // Set the additional authenticated data (AAD) success = crypt.SetEncodedAad(AAD, "hex"); // For the purpose of duplicating the test vectors, we are using the EncryptEncoded method. // This method decodes the input string according to the encoding specified by the EncodingMode // property, which in this case is "hex". The decoded bytes are encrypted using the mode specified // by the CipherMode property. The resulting // encrypted bytes are encoded (again using the encoding mode specified by EncodingMode), // and the result is returned. // <b>Note:</b> The CipherMode property sets the block mode of operation (gcm, cfb, cbc, ofb, ecb, etc.) // for any of the Chilkat encryption/decryption methods (such as EncryptBytes, EncryptString, // CkEncryptFile, etc.) Just because GCM mode is demonstrated with EncryptEncoded/DecryptEncoded, // does not imply that GCM mode is specific to only these methods. string ctResult = crypt.EncryptEncoded(PT); if (crypt.LastMethodSuccess != true) { // Console.WriteLine(crypt.LastErrorText); return; } // Examine the result. It should be the same (case insensitive) as our expected result: // Console.WriteLine("computed result: " + ctResult); // Console.WriteLine("expected result: " + CT); // Examine the authenticated tag. It should be the same (case insensitive) as our expected authenticated tag: string tResult = crypt.GetEncodedAuthTag("hex"); //Console.WriteLine("computed authTag: " + tResult); //Console.WriteLine("expected authTag: " + T); // ------------------------------------------------------------------------------------- // Now let's GCM decrypt... // ------------------------------------------------------------------------------------- // Before GCM decrypting, we must set the authenticated tag to the value that is expected. // The decryption will fail if the resulting authenticated tag is not equal (case insensitive) to // the expected result. // Note: The return value of SetEncodedAuthTag indicates whether the string passed was a valid // representation of the encoding specified in the 2nd arg. success = crypt.SetEncodedAuthTag(T, "hex"); // All of our properties (IV, secret key, cipher mode, and AAD) are already set from the code above... // So let's decrypt CT to and check to see if we get PT. string ptResult = crypt.DecryptEncoded(CT); if (crypt.LastMethodSuccess != true) { // Failed. The resultant authenticated tag did not equal the expected authentication tag. // Console.WriteLine(crypt.LastErrorText); return; } // Examine the decrypted result. It should be the same as our expected plaintext (case insensitive) //Console.WriteLine("plaintext decrypted: " + ptResult); //Console.WriteLine("plaintext expected: " + PT); // Let's intentionally set the expected authenticated tag to an incorrect value. // The decrypt operation should fail: string tInvalid = "ffaabbbc3221a5db94fae95ae7121a47"; success = crypt.SetEncodedAuthTag(tInvalid, "hex"); ptResult = crypt.DecryptEncoded(CT); if (crypt.LastMethodSuccess != true) { // Failed. The resultant authenticated tag did not equal the expected authentication tag. // Console.WriteLine(crypt.LastErrorText); } }
public static string DecryptRijndael(string _key, string _string) { Chilkat.Crypt2 _encrypt = new Chilkat.Crypt2(); bool isUnlocked = _encrypt.UnlockComponent("SCOTTGCrypt_FdXsYk2WWPjN"); // AES is also known as Rijndael. _encrypt.CryptAlgorithm = "aes"; // CipherMode may be "ecb" or "cbc" _encrypt.CipherMode = "cbc"; // KeyLength may be 128, 192, 256 _encrypt.KeyLength = 256; // The padding scheme determines the contents of the bytes // that are added to pad the result to a multiple of the // encryption algorithm's block size. AES has a block // size of 16 bytes, so encrypted output is always // a multiple of 16. _encrypt.PaddingScheme = 0; // EncodingMode specifies the encoding of the output for // encryption, and the input for decryption. // It may be "hex", "url", "base64", or "quoted-printable". _encrypt.EncodingMode = "hex"; // An initialization vector is required if using CBC mode. // ECB mode does not use an IV. // The length of the IV is equal to the algorithm's block size. // It is NOT equal to the length of the key. string ivHex; ivHex = "000102030405060708090A0B0C0D0E0F"; _encrypt.SetEncodedIV(ivHex,"hex"); // The secret key must equal the size of the key. For // 256-bit encryption, the binary secret key is 32 bytes. // For 128-bit encryption, the binary secret key is 16 bytes. string keyHex; keyHex = _key; _encrypt.SetEncodedKey(keyHex,"hex"); // Now decrypt: return _encrypt.DecryptStringENC(_string); }
static string HttpGet(string url) { bool success = false; HttpWebRequest req = WebRequest.Create(url) as HttpWebRequest; string Token = String.Format("{0:yyyy-MM-dd HH:mm:ss}", new DateTime(2010, 02, 02, 21, 15, 0)); //SIGN Chilkat.PrivateKey privkey1 = new Chilkat.PrivateKey(); privkey1.LoadPem(mykey); Chilkat.Rsa rsa1 = new Chilkat.Rsa(); success = rsa1.UnlockComponent("HAFSJORSA_K36nxU3n1Yui"); success = rsa1.ImportPrivateKey(privkey1.GetXml()); rsa1.EncodingMode = "base64"; rsa1.Charset = "ANSI"; rsa1.LittleEndian = false; rsa1.OaepPadding = false; string hexSig = rsa1.SignStringENC(Token, "sha-1"); //VERIFY Chilkat.Cert cert2 = new Chilkat.Cert(); success = cert2.LoadFromBase64(mycert); Chilkat.PublicKey pubKey2 = null; pubKey2 = cert2.ExportPublicKey(); Chilkat.Rsa rsa2 = new Chilkat.Rsa(); success = rsa2.ImportPublicKey(pubKey2.GetXml()); rsa2.EncodingMode = "base64"; rsa2.Charset = "ANSI"; rsa2.LittleEndian = false; rsa2.OaepPadding = false; success = rsa2.VerifyStringENC(Token, "sha-1", hexSig); req.Headers.Add("Token", Token); req.Headers.Add("Signature", hexSig); //ENCRYPT Chilkat.Cert cert3 = new Chilkat.Cert(); success = cert3.LoadFromBase64(mycert); Chilkat.PublicKey pubKey3 = null; pubKey3 = cert3.ExportPublicKey(); Chilkat.Rsa rsa3 = new Chilkat.Rsa(); success = rsa3.UnlockComponent("HAFSJORSA_K36nxU3n1Yui"); rsa3.EncodingMode = "base64"; rsa3.Charset = "ANSI"; rsa3.LittleEndian = true; rsa3.OaepPadding = false; rsa3.ImportPublicKey(pubKey3.GetXml()); bool usePrivateKey = false; System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding(); byte[] TokenArr = encoding.GetBytes(Token); //byte[] encryptedArr = rsa3.EncryptBytes(TokenArr, usePrivateKey); string encryptedstr = rsa3.EncryptBytesENC(TokenArr, usePrivateKey); //DECRYPT Chilkat.Rsa rsa4 = new Chilkat.Rsa(); rsa4.EncodingMode = "base64"; rsa4.Charset = "ANSI"; rsa4.LittleEndian = true; rsa4.OaepPadding = false; rsa4.ImportPrivateKey(privkey1.GetXml()); usePrivateKey = true; //encryptedStr = "XJ65xTR/xvD2N9xBKyKPqPijqTAyJuVtOlbaFUIboJaEPHH9pv+Lhrd5o6MSwKF6TeXs6hVsKnj8jVeYFYoEDgJS95GqaaUomWBhEZYchOp/6dn3ZxCeQoljAWLt6m4C829R9b5JYatYar9YV0d+QV+jVWE4U0rlNrkTqtA02Qw4ztN4/oehgCISrBnc81N1MYNwG9vrTHSVM6tSUWjWxMRubpOBvqKqOxyA9fpJNHgUyzio2X1cp12K++1GEUWNWyYVhTiBr/QM3mUN67mHcn0vvWZvmPhYlIaVn9DqIvVdMbHRbLwrCczFgY4PdHrhcH9yDTlkkAbKUatgDQiI4w=="; //encryptedStr = "6KQbxh+x5SGIzD89zEwj+/IVVCBocemCXWl1mr+mk9wxRMydCfmMSUHDOafnqiJ6GAJapKbLTHOc9d1OyWTwsp5BQBT5VM20hb9r+AkDrHwkgL06ifizP0gTEO17cyO95jwlRXOfkQKb3cERLBEtOAnRep4bKMSsPLyxRRBX5VT4d19yxRor2V9js0CEFONinxl7qRxjckwvQk53+qpxeQ8jOx+pmrQukX7nWkMajWi+ZFndyfLL3LfRBYZKN2R0vdrnSMKdkxUEUUJybsv4QCMWshNpQznPSantq2dKNe07eB5mX4fRufy4mY4qjqBlf8+XFKdD+J37C6r3THL6pw=="; //string decryptedStr = rsa4.DecryptStringENC(encryptedStr, usePrivateKey); Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); success = crypt.UnlockComponent("HAFSJOCrypt_0xo09cJWVQAw"); crypt.EncodingMode = "base64"; crypt.CryptAlgorithm = "none"; req.Headers.Add("authorization", "Basic " + crypt.EncryptStringENC("Mogens:Hafsjold")); string result = null; using (HttpWebResponse resp = req.GetResponse() as HttpWebResponse) { StreamReader reader = new StreamReader(resp.GetResponseStream()); result = reader.ReadToEnd(); } return(result); }
// URLs to help understand this topic: // https://developers.google.com/identity/protocols/OAuth2InstalledApp // private bool oauth2_google(string scope) { // Generates state and PKCE values. string state = m_prng.GenRandom(32, base64Url); string code_verifier = m_prng.GenRandom(32, base64Url); Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); crypt.EncodingMode = base64Url; crypt.HashAlgorithm = "SHA256"; string code_challenge = crypt.HashStringENC(code_verifier); const string code_challenge_method = "S256"; //Create a Chilkat socket for listening. Begin listening asynchronously. Chilkat.Socket listenSocket = new Chilkat.Socket(); int backlog = 5; int listenPort = 0; // Passing a listenPort = 0 causes BindAndListen to find a random unused port. // The chosen port will be available via the ListenPort property. if (!listenSocket.BindAndListen(listenPort, backlog)) { fgAppendToErrorLog(listenSocket.LastErrorText); popupError("Failed to BindAndListen"); return(false); } // Get the chosen listen port // This ListenPort property is available starting in Chilkat v9.5.0.59 listenPort = listenSocket.ListenPort; // Creates a redirect URI using an available port on the loopback address. string redirect_uri = "http://127.0.0.1:" + listenPort.ToString() + "/"; //Wait a max of 5 minutes. The OnTaskCompleted event is called when an incoming connection //arrives, or when the listen failed. listenSocket.OnTaskCompleted += listenSocket_OnTaskCompleted; Chilkat.Task task = listenSocket.AcceptNextConnectionAsync(5 * 60000); if (task == null) { MessageBox.Show("Failed to start socket accept..."); return(false); } // Add some information that will be needed by the TaskCompleted event.. Chilkat.JsonObject taskData = new Chilkat.JsonObject(); taskData.AppendString("code_verifier", code_verifier); taskData.AppendString("redirect_uri", redirect_uri); task.UserData = taskData.Emit(); // Start the task. task.Run(); // Creates the OAuth 2.0 authorization request. Chilkat.StringBuilder sbAuthRequest = new Chilkat.StringBuilder(); sbAuthRequest.Append(authorizationEndpoint); sbAuthRequest.Append("?response_type=code&scope="); sbAuthRequest.Append(m_encoder.EncodeString(scope, "utf-8", "url")); sbAuthRequest.Append("&redirect_uri="); sbAuthRequest.Append(m_encoder.EncodeString(redirect_uri, "utf-8", "url")); sbAuthRequest.Append("&client_id="); sbAuthRequest.Append(googleAppClientId); sbAuthRequest.Append("&state="); sbAuthRequest.Append(state); sbAuthRequest.Append("&code_challenge="); sbAuthRequest.Append(code_challenge); sbAuthRequest.Append("&code_challenge_method="); sbAuthRequest.Append(code_challenge_method); // Here is a shorter way of building the URL in C# //string authorizationRequest = string.Format("{0}?response_type=code&scope={6}&redirect_uri={1}&client_id={2}&state={3}&code_challenge={4}&code_challenge_method={5}", // authorizationEndpoint, // 0 // System.Uri.EscapeDataString(redirect_uri), // 1 // googleAppClientId, // 2 // state, // 3 // code_challenge, // 4 // code_challenge_method, // 5 // System.Uri.EscapeDataString(scope)); // 6 // Get authorization from Google account owner... webBrowser1.Navigate(sbAuthRequest.GetAsString()); return(true); }
public static void CreateValue(string passwordPhrase) { Random random = new Random(); int num_letters = 5; char[] letters = "abcdefghijklmnopqrstuvwxyz1234567890".ToCharArray(); string word = ""; for (int j = 1; j <= num_letters; j++) { int letter_num = random.Next(0, letters.Length - 1); word += letters[letter_num]; } string phraseForHash = passwordPhrase + word; //DES - блоковий DES DESalg = DES.Create(); string FileName = "des.txt"; EncryptTextToFile(phraseForHash, FileName, DESalg.Key, DESalg.IV); FileStream fStream = File.Open(FileName, FileMode.OpenOrCreate); StreamReader streamReader = new StreamReader(fStream); string desKey = streamReader.ReadLine(); fStream.Close(); streamReader.Close(); //CFB - зворотній зв'язок byte[] plainBytes = Encoding.UTF8.GetBytes(desKey); byte[] savedKey = new byte[16]; byte[] savedIV = new byte[16]; byte[] cipherBytes; using (RijndaelManaged Aes128 = new RijndaelManaged()) { Aes128.BlockSize = 128; Aes128.KeySize = 128; Aes128.Mode = CipherMode.CFB; Aes128.FeedbackSize = 8; Aes128.Padding = PaddingMode.None; Aes128.GenerateKey(); Aes128.GenerateIV(); Aes128.Key.CopyTo(savedKey, 0); Aes128.IV.CopyTo(savedIV, 0); using (var encryptor = Aes128.CreateEncryptor()) using (var msEncrypt = new MemoryStream()) using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) using (var bw = new BinaryWriter(csEncrypt, Encoding.UTF8)) { bw.Write(plainBytes); bw.Close(); cipherBytes = msEncrypt.ToArray(); } } string cfbKey = cipherBytes.ToString(); //MD2 Chilkat.Crypt2 crypt = new Chilkat.Crypt2(); crypt.HashAlgorithm = "md2"; string hashFinal = crypt.HashStringENC(cfbKey); FileStream fStreamF = File.Open("hash.txt", FileMode.OpenOrCreate); StreamWriter sWriter = new StreamWriter(fStreamF); sWriter.WriteLine(hashFinal); sWriter.Close(); fStreamF.Close(); }