public NetCryptoProviderBase(NetPeer peer, SymmetricAlgorithm algo)
: base(peer)
{
m_algorithm = algo;
m_algorithm.GenerateKey();
m_algorithm.GenerateIV();
}
static Secure()
{
try
{
var secureSettings = MassiveDB.Current.FindSettings("Secure");
algorithm = new RijndaelManaged();
if (secureSettings.Count() != 2)
{
MassiveDB.Current.RemoveDomainSettings("Secure");
algorithm.GenerateIV();
algorithm.GenerateKey();
MassiveDB.Current.InsertDomainSetting("Secure", "IV", Convert.ToBase64String(algorithm.IV));
MassiveDB.Current.InsertDomainSetting("Secure", "Key", Convert.ToBase64String(algorithm.Key));
}
else
{
algorithm.IV = Convert.FromBase64String(secureSettings.Single(s => s.Identifier == "IV").SettingValue);
algorithm.Key = Convert.FromBase64String(secureSettings.Single(s => s.Identifier == "Key").SettingValue);
}
}
catch (Exception ex)
{
algorithm = null;
initException = ex;
}
}
private void initOther()
{
provider.Mode = defaultMode;
provider.Padding = defaultPadding;
provider.GenerateIV();
provider.GenerateKey();
}
/// <summary> Creates a new key </summary>
public AESCryptoKey()
{
_key = new RijndaelManaged();
_key.Padding = PaddingMode.PKCS7;
_key.KeySize = 256;
_key.IV = _iv ?? ProcessDefaultIV;
_key.GenerateKey();
}
byte[] GenerateUnprotectedKey(SymmetricAlgorithm algorithm)
{
using (algorithm)
{
algorithm.GenerateKey();
return algorithm.Key;
}
}
public cryptography(bool IsConsole, bool oldExpansionMethod = false)
{
isConsole = IsConsole;
oldFormatKeyExpansion = oldExpansionMethod;
twoFish = new Twofish();
twoFish.Mode = CipherMode.CBC;
twoFish.GenerateIV();
twoFish.GenerateKey();
}
private byte[] GenerateUnprotectedKey(SymmetricAlgorithm algorithm)
{
byte[] generatedKey = null;
using (algorithm)
{
algorithm.GenerateKey();
generatedKey = algorithm.Key;
}
return generatedKey;
}
/// <summary>
/// 获得密钥
/// </summary>
/// <returns>密钥</returns>
private static byte[] GetLegalKey(SymmetricAlgorithm mobjCryptoService)
{
string sTemp = "Cuz(%&hj7x89H$yuBI0456FtmaT5&fvHUFCy76*h%(HilJ$lhj!y6&(*jkP87jH1";
mobjCryptoService.GenerateKey();
byte[] bytTemp = mobjCryptoService.Key;
int KeyLength = bytTemp.Length;
if (sTemp.Length > KeyLength)
sTemp = sTemp.Substring(0, KeyLength);
else if (sTemp.Length < KeyLength)
sTemp = sTemp.PadRight(KeyLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
/// <summary>
/// Initializes a new instance of the RegistrationEncryptionEngine class
/// </summary>
public EncryptionEngine()
{
_sa = DES.Create(); //Create();
_sa.Padding = PaddingMode.PKCS7;
_sa.Mode = CipherMode.ECB;
_sa.GenerateKey();
// _sa.GenerateIV();
// byte[] iv = _sa.IV;
_sa.IV = _iv;
}
public void Build(SymmetricAlgorithm algorithm)
{
if (algorithm == null)
throw new ArgumentNullException("algorithm");
using (algorithm)
{
algorithm.KeySize = CurrentKeySize;
algorithm.BlockSize = CurrentBlockSize;
algorithm.Mode = SelectedCipher;
algorithm.Padding = SelectedPadding;
algorithm.GenerateIV();
algorithm.GenerateKey();
textBoxIV.Text = Convert.ToBase64String(algorithm.IV);
textBoxKey.Text = Convert.ToBase64String(algorithm.Key);
}
}
static void EncryptorType(SymmetricAlgorithm sa, string file_output, string file_input)
{
sa.GenerateKey();
sa.GenerateIV();
ICryptoTransform transform = sa.CreateEncryptor(sa.Key, sa.IV);
using (FileStream file = new FileStream(file_output, FileMode.Create, FileAccess.Write))
{
using( CryptoStream stream = new CryptoStream(file, transform, CryptoStreamMode.Write))
using (FileStream input = new FileStream(file_input, FileMode.Open))
{
input.CopyTo(stream);
}
using (StreamWriter key = new StreamWriter("file.key.txt"))
{
string s = Convert.ToBase64String(sa.IV);
key.WriteLine(s);
s = Convert.ToBase64String(sa.Key);
key.Write(s);
}
}
}
public static byte[] EncryptString(string source, SymmetricAlgorithm algorithm)
{
byte[] buffer;
algorithm.GenerateIV();
algorithm.GenerateKey();
using (MemoryStream stream = new MemoryStream(0x80))
{
using (new BinaryWriter(stream))
{
stream.Write(algorithm.IV, 0, algorithm.IV.Length);
stream.Write(algorithm.Key, 0, algorithm.Key.Length);
using (CryptoStream stream2 = new CryptoStream(stream, algorithm.CreateEncryptor(), CryptoStreamMode.Write))
{
using (TextWriter writer2 = new StreamWriter(stream2))
{
writer2.Write(source);
}
}
buffer = stream.ToArray();
}
}
return buffer;
}
private void SetEncryptor() {
switch (_mbytEncryptionType) {
case SymmetricEncryptType.Des:
_mCsp = new DESCryptoServiceProvider();
break;
case SymmetricEncryptType.Rc2:
_mCsp = new RC2CryptoServiceProvider();
break;
case SymmetricEncryptType.Rijndael:
_mCsp = new RijndaelManaged();
break;
case SymmetricEncryptType.TripleDes:
_mCsp = new TripleDESCryptoServiceProvider();
break;
}
_mCsp.GenerateKey();
_mCsp.GenerateIV();
}
private static void GenerarClave(SymmetricAlgorithm algoritmo)
{
// Establecemos la longitud que queremos que tenga la clave a generar.
algoritmo.KeySize = 256;
Console.WriteLine("Longitud de la clave: {0}", algoritmo.KeySize);
Console.WriteLine("Pulse una tecla para continuar…\n");
Console.ReadKey();
// Leer sin más el valor de la clave hara que se genere.
// sacamos la clave por consola
Console.WriteLine("La clave: ");
foreach (byte b in algoritmo.Key)
{
Console.Write("{0:X2} ", b);
}
Console.WriteLine("\nPulse una tecla para continuar…\n");
Console.ReadKey();
// Podemos generar otra nueva
algoritmo.GenerateKey();
// sacamos la nueva clave por consola
Console.WriteLine("Otra clave: ");
foreach (byte b in algoritmo.Key)
{
Console.Write("{0:X2} ", b);
}
Console.WriteLine("\nPulse una tecla para continuar…\n");
Console.ReadKey();
// Otra forma de crear claves sería con RNG (Random Number Generator)
RandomNumberGenerator randomNumberGenerator =
RandomNumberGenerator.Create();
// Se rellena el array de bytes de la clave con datos aleatorios
randomNumberGenerator.GetBytes(algoritmo.Key);
// sacamos la clave por consola
Console.WriteLine("Otra forma de obtener una clave: ");
foreach (byte b in algoritmo.Key)
{
Console.Write("{0:X2} ", b);
}
Console.WriteLine("\nPulse una tecla para continuar…\n");
Console.ReadKey();
}
public override void GenerateKey()
{
m_impl.GenerateKey();
}
private byte[] GetLegalKey(SymmetricAlgorithm cryptoObj)
{
if (string.IsNullOrEmpty(key))
key = DEFAULT_KEY;
string sTemp = key;
cryptoObj.GenerateKey();
byte[] bytTemp = cryptoObj.Key;
int KeyLength = bytTemp.Length;
if (sTemp.Length > KeyLength)
sTemp = sTemp.Substring(0, KeyLength);
else if (sTemp.Length < KeyLength)
sTemp = sTemp.PadRight(KeyLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
/// <summary>
/// Generates the symmetric key.
/// </summary>
/// <param name="algorithm">The algorithm.</param>
/// <returns></returns>
public static byte[] GenerateSymmetricKey(SymmetricAlgorithm algorithm)
{
algorithm.GenerateKey();
return algorithm.Key;
}
private void GenerateKey(SymmetricAlgorithm alg)
{
alg.GenerateKey();
alg.GenerateIV();
Debug.WriteLine("Algorithm: " + alg.GetType().Name.PadRight(30) + " keySize(bits): " + alg.KeySize + " key: " + HexUtil.ByteArrayToHex(alg.Key));
}
private static byte[] GetLegalKey(SymmetricAlgorithm mobjCryptoService, string key)
{
string sTemp = key;
mobjCryptoService.GenerateKey();
byte[] bytTemp = mobjCryptoService.Key;
int KeyLength = bytTemp.Length;
if (sTemp.Length > KeyLength)
sTemp = sTemp.Substring(0, KeyLength);
else if (sTemp.Length < KeyLength)
sTemp = sTemp.PadRight(KeyLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
/// <summary>
/// Creates a random key value appropriate for
/// the encryption algorithm
/// </summary>
/// <param name="encryptionAlgorithm">Instance of SymmetricAlgorithm used to create the key</param>
/// <returns>Base64 encoded byte array containing the key value</returns>
public static string CreateBase64Key(SymmetricAlgorithm encryptionAlgorithm)
{
byte[] key = null;
try
{
encryptionAlgorithm.GenerateKey();
key = encryptionAlgorithm.Key;
}
finally
{
encryptionAlgorithm.Clear();
((IDisposable)encryptionAlgorithm).Dispose();
}
return Convert.ToBase64String(key);
}
