protected void Page_Load(object sender, EventArgs e)
{
try
{
if (!IsPostBack && !IsCallback)
{
securityAgent = new CryptoProvider();
if (Request.QueryString["UID"] != null && Request.QueryString["UN"] != null)
{
txtUserName.Text = securityAgent.decryptText(Request.QueryString["UN"].Replace(" ", "+"));
txtPassword.Focus();
}
else
{
Response.Redirect("Logout.aspx");
}
}
}
catch (Exception ex)
{
lblErr.Text = "There was a problem processing your request. Please contact IT.";
lblErr.Visible = true;
CommonHelpers.writeLogToFile("Page_Load: ResetPassword.aspx.aspx", ex.Message);
}
}
public void NullFilterTest()
{
var filter1 = new FindFilter();
var filter2 = new FindFilter();
foreach (var field in Enum.GetValues(typeof(StringField)).Cast <StringField>())
{
filter1.KeyIsNull(field);
filter2.KeyIsNotNull(field);
}
foreach (var field in Enum.GetValues(typeof(NumberField)).Cast <NumberField>())
{
filter1.KeyIsNull(field);
filter2.KeyIsNotNull(field);
}
using var provider = new CryptoProvider();
var transformer = new DtoTransformer(provider, new HashUtils("envId", false, Encoding.UTF8));
Assert.IsTrue(JsonEquals(JsonFilterNull,
JsonConvert.SerializeObject(transformer.TransformFilter(filter1), s_jsonSettings)));
Assert.IsTrue(JsonEquals(JsonFilterNotNull,
JsonConvert.SerializeObject(transformer.TransformFilter(filter2), s_jsonSettings)));
}
protected void cmdSubmit_Click(object sender, EventArgs e)
{
try
{
if (txtNewPassword.Text.Equals(txtConfirm.Text))
{
securityAgent = new CryptoProvider();
DBAgent = new DataAccessProvider(DataAccessProvider.ParamType.ServerCredentials, ConfigurationManager.AppSettings["DBServerName"], ConfigurationManager.AppSettings["DBUserName"], ConfigurationManager.AppSettings["DBPassword"]);
DBAgent.AddParameter("@ParamLoginID", securityAgent.decryptText(Request.QueryString["UID"].Replace(" ", "+")));
DBAgent.AddParameter("@ParamNewPassword", securityAgent.EncryptText(txtNewPassword.Text));
DBAgent.AddParameter("@ParamIsTempPassword", 0);
DBAgent.ExecuteNonQuery("dbo.spUpdatePassword");
Session["Username"] = securityAgent.decryptText(Request.QueryString["UN"].Replace(" ", "+"));
Session["LoginID"] = securityAgent.decryptText(Request.QueryString["UID"].Replace(" ", "+"));
Response.Redirect("Dashboard.aspx");
}
}
catch (Exception ex)
{
lblErr.Text = "There was a problem processing your request. Please contact IT.";
lblErr.Visible = true;
CommonHelpers.writeLogToFile("cmdSubmit_Click: ResetPassword.aspx.aspx", ex.Message);
}
}
public async Task <string> GetLicense()
{
string result = "";
try
{
using (var fs = new FileStream(AppDomain.CurrentDomain.BaseDirectory + @"uploads\lic.dat", FileMode.Open, FileAccess.ReadWrite))
{
using (var sr = new StreamReader(fs))
{
var feename = _tblSystemConfigService.GetDefault().FeeName;
var fileContent = sr.ReadToEnd();
var decryptedData = CryptoProvider.SimpleDecryptWithPassword(fileContent, SecurityModel.License_Key);
var licData = JsonConvert.DeserializeObject <List <MN_License> >(decryptedData);
var currentLic = licData.Where(p => p.ProjectName == feename).FirstOrDefault();
if (currentLic != null)
{
var expireDate = DateTime.Now;
DateTime.TryParseExact(currentLic.ExpireDate, "dd/MM/yyyy HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out expireDate);
result = $"{currentLic.ProjectName};{currentLic.IsExpire};{expireDate.ToString("yyyy/MM/dd HH:mm")}";
}
}
}
}
catch (Exception ex)
{
}
return(await Task.FromResult(result));
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
internal RightsManagementEncryptedStream(
Stream baseStream,
CryptoProvider cryptoProvider)
{
Debug.Assert(baseStream != null);
Debug.Assert(cryptoProvider != null);
if (!cryptoProvider.CanDecrypt)
{
throw new ArgumentException(SR.Get(SRID.CryptoProviderCanNotDecrypt), "cryptoProvider");
}
if (!cryptoProvider.CanMergeBlocks)
{
throw new ArgumentException(SR.Get(SRID.CryptoProviderCanNotMergeBlocks), "cryptoProvider");
}
_baseStream = baseStream;
_cryptoProvider = cryptoProvider;
// Currently BitConverter is implemented as only supporting Little Endian byte order
// regardless of the machine type. We would like to make sure that this doesn't change
// as we need Little Endian byte order decoding capability on all machines in order to
// parse files that travel across different machine types.
Debug.Assert(BitConverter.IsLittleEndian);
// initialize stream length
ParseStreamLength();
}
/// <summary>
/// Initializes a new instance of the SymmetricKey class.
/// </summary>
/// <param name="provider">One of the <see cref="CryptoProvider"/> values.</param>
/// <param name="algorithm">One of the <see cref="CryptoAlgorithm"/> values.</param>
/// <exception cref="SecurityException">An error occurs when generating a new key.</exception>
public SymmetricKey(CryptoProvider provider, CryptoAlgorithm algorithm) : this(provider) {
m_Handle = 0;
if (SspiProvider.CryptGenKey(m_Provider, new IntPtr((int)algorithm), SecurityConstants.CRYPT_EXPORTABLE, ref m_Handle) == 0)
{
throw new SecurityException("Cannot generate session key.");
}
}
public async Task <User> Register(string username, string password)
{
var userServiceModel = await _usersService.RegisterUser(username.ToLower()) ?? await _usersService.GetUser(username.ToLower());
if (userServiceModel == null)
{
return(null);
}
if (!await _portfolioService.CreatePortfolio(userServiceModel.UserId))
{
return(null);
}
if (!await _bankService.CreateBankAndAccount(userServiceModel.UserId))
{
return(null);
}
var cipher = CryptoProvider.Encrypt(new CryptoProvider.Plain {
Password = password
});
var user = new User
{
UserId = userServiceModel.UserId,
Username = userServiceModel.Email,
Hash = cipher.Hash,
Salt = cipher.Salt
};
_unitOfWork.AuthenticationRepository.Register(user);
await _unitOfWork.CommitAsync();
return(user);
}
public EcdsaKeyPair GetRandomKey()
{
var crypto = CryptoProvider.GetCrypto();
var privateKey = crypto.GeneratePrivateKey().ToPrivateKey();
return(new EcdsaKeyPair(privateKey));
}
public ManagerBitLockerUnlockHandler(IBroadcaster broadcaster, IDeviceController deviceController, ISession session, CryptoProvider cryptor)
{
this.broadcaster = broadcaster;
this.deviceController = deviceController;
this.session = session;
this.cryptor = cryptor;
}
/// <summary>
/// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.
/// </summary>
/// <param name="cryptProvider">Tipo de criptografia.</param>
public Crypto(CryptoProvider cryptProvider)
{
// Seleciona algoritmo simétrico
switch (cryptProvider)
{
case CryptoProvider.Rijndael:
_algorithm = new RijndaelManaged();
_cryptProvider = CryptoProvider.Rijndael;
break;
case CryptoProvider.RC2:
_algorithm = new RC2CryptoServiceProvider();
_cryptProvider = CryptoProvider.RC2;
break;
case CryptoProvider.DES:
_algorithm = new DESCryptoServiceProvider();
_cryptProvider = CryptoProvider.DES;
break;
case CryptoProvider.TripleDES:
_algorithm = new TripleDESCryptoServiceProvider();
_cryptProvider = CryptoProvider.TripleDES;
break;
}
_algorithm.Mode = CipherMode.CBC;
}
public void GetSecretsDataNegativeTest()
{
using var cryptoManager = new CryptoProvider();
var hashProvider = new HashUtils(EnvId, false, Encoding.UTF8);
const string errorMessage = "testError";
var transformer = new DtoTransformer(cryptoManager, hashProvider, true,
() => throw new StorageClientException(errorMessage));
var exception = Assert.Throws <StorageClientException>(() =>
transformer.GetRecord(new TransferRecord("recordKey", "recordBody")));
Assert.AreEqual(errorMessage, exception.Message);
transformer = new DtoTransformer(cryptoManager, hashProvider, true,
() => throw new NotImplementedException());
exception = Assert.Throws <StorageClientException>(() =>
transformer.GetRecord(new TransferRecord("recordKey", "recordBody")));
Assert.AreEqual("Unexpected error", exception.Message);
Assert.IsNotNull(exception.InnerException);
Assert.IsInstanceOf <NotImplementedException>(exception.InnerException);
transformer = new DtoTransformer(cryptoManager, hashProvider, true, () => null);
exception = Assert.Throws <StorageClientException>(() =>
transformer.GetRecord(new TransferRecord("recordKey", "recordBody")));
Assert.AreEqual("Secret accessor returns null secret", exception.Message);
}
public void GetFilterWithNonHashingModeTest()
{
using var cryptoManager = new CryptoProvider();
var hashProvider = new HashUtils(EnvId, false, Encoding.UTF8);
var transformer = new DtoTransformer(cryptoManager, hashProvider, false);
var filter = new FindFilter()
.KeyEq(StringField.RecordKey, "some record key")
.KeyEq(StringField.Key1, "some value of key1");
var filterContainer = transformer.TransformFilter(filter);
var jsonSettings = new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver {
NamingStrategy = new SnakeCaseNamingStrategy()
},
Formatting = Formatting.None,
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Include
};
var json = JsonConvert.SerializeObject(filterContainer, jsonSettings);
Assert.AreEqual("{\"filter\":{\"record_key\":[\"2ab632ee5ebf3af90be1ae6accea46d99843fdc4676bb29a376919fa9c530364\"]," +
"\"key1\":[\"some value of key1\"]}," +
"\"options\":{\"limit\":100,\"offset\":0}}",
json);
}
public JwtSecurityToken VerifyToken(string inputToken)
{
if (string.IsNullOrWhiteSpace(inputToken))
{
throw new Exception("Token string can not be null.");
}
JwtSecurityTokenHandler handler = new JwtSecurityTokenHandler();
if (!handler.CanReadToken(inputToken))
{
return(null);
}
var tokenToVerify = handler.ReadJwtToken(inputToken);
var encHeader = tokenToVerify.Header.Base64UrlEncode();
var encPayload = tokenToVerify.Payload.Base64UrlEncode();
var sign = CryptoProvider.GenerateSHMACHash($"{encHeader}.{encPayload}");
if (tokenToVerify.RawSignature != sign)
{
return(null);
}
if (tokenToVerify.Payload.ValidTo < DateTime.Now)
{
return(null);
}
return(tokenToVerify);
}
public void TransformFindFilterTest()
{
using var cryptoManager = new CryptoProvider();
var hashProvider = new HashUtils(EnvId, false, Encoding.UTF8);
var transformer = new DtoTransformer(cryptoManager, hashProvider);
var filter = new FindFilter()
.KeyEq(StringField.Key1, "value1")
.KeyEq(NumberField.Version, 0);
var jsonSettings = new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver {
NamingStrategy = new SnakeCaseNamingStrategy()
},
Formatting = Formatting.None,
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Include
};
var transformFilter = transformer.TransformFilter(filter);
Assert.IsTrue(FindFilterTest.JsonEquals(
"{\"filter\":{\"key1\":[\"327c84457a2ff2c6da36314dc0ffb3216a283570a5c4654d5f51947e74742cf0\"]," +
"\"version\":[0]},\"options\":{\"limit\":100,\"offset\":0}}",
JsonConvert.SerializeObject(transformFilter, jsonSettings)));
}
public bool Handle(IPacket header, IIBLVMSocket socket)
{
if (header.Type == PacketType.ServerKeyResponse)
{
Utils.PacketValidation(socket.Status, (int)ClientSocketStatus.Handshaking, header.GetPayloadSize(), false);
CryptoProvider cryptoProvider = socket.CryptoProvider;
IPayload <byte[]> packet = socket.PacketFactory.CreateServerKeyResponse(null);
packet.ParsePayload(header.GetPayloadSize(), socket.SocketStream);
cryptoProvider.SharedKey = cryptoProvider.ECDiffieHellman.DeriveKeyMaterial(CngKey.Import(packet.Payload, CngKeyBlobFormat.EccPublicBlob));
cryptoProvider.CryptoStream = new CryptoMemoryStream(cryptoProvider.SharedKey);
byte[] nonce = new byte[cryptoProvider.CryptoStream.IV.Length];
Array.Copy(cryptoProvider.SharedKey, nonce, nonce.Length);
cryptoProvider.CryptoStream.IV = nonce;
IPacket responsePacket = socket.PacketFactory.CreateClientKeyResponse(cryptoProvider.ECDiffieHellman.PublicKey.ToByteArray());
Utils.SendPacket(socket.SocketStream, responsePacket);
socket.Status = (int)ClientSocketStatus.Connected;
return(true);
}
return(false);
}
public async Task <AuthCode> CheckCode(string recipient, string code, bool updateUsage = true)
{
return(await Task.Run <AuthCode>(() =>
{
AuthCode authCode = null;
var codeQuery = new { Recipient = recipient, CodeHash = CryptoProvider.SHA1(code.ToUpper()).ToLower() };
authCode = _dataManager.Get <AuthCode>(codeQuery);
if (authCode == null || authCode.UsedTime.HasValue)
{
throw new ApplicationException("کد تائید کاربر نامعتبر میباشد.");
}
if (authCode.ExpieryTime < DateTimeOffset.UtcNow)
{
throw new ApplicationException("کد تائید کاربر منقضی شده و غیر قابل استفاده میباشد.");
}
if (updateUsage)
{
var usedTime = DateTimeOffset.UtcNow;
var count = _dataManager.Update <AuthCode>(new { UsedTime = usedTime }, new { Id = authCode.Id });
if (count <= 0)
{
throw new ApplicationException("خطا در بروز رسانی وضعیت کد تائید کاربر.");
}
authCode.UsedTime = usedTime;
}
return authCode;
}));
}
public static String DecryptCsvFile(Stream file, CryptoProvider crypto)
{
StringBuilder sb = new StringBuilder();
using (StreamReader reader = new StreamReader(file))
{
String line;
while ((line = reader.ReadLine()) != null)
{
char[] delims = { ',' };
String[] values = line.Split(delims);
bool firstValue = true;
foreach (String value in values)
{
String rawValue = value.Trim('"', ' ');
String newValue = null;
crypto.TryDecryptOrValue(rawValue, out newValue);
if (firstValue)
{
firstValue = false;
}
else
{
sb.Append(",");
}
sb.Append(newValue);
}
sb.AppendLine(String.Empty);
}
reader.Close();
}
return(sb.ToString());
}
/// <summary>
/// Initializes a new instance of the SymmetricKey class.
/// </summary>
/// <param name="provider">One of the <see cref="CryptoProvider"/> values.</param>
/// <param name="algorithm">One of the <see cref="CryptoAlgorithm"/> values.</param>
/// <param name="buffer">An array of bytes that contains the key to import.</param>
public SymmetricKey(CryptoProvider provider, CryptoAlgorithm algorithm, byte[] buffer) : this(provider) {
if (buffer == null)
{
throw new ArgumentNullException();
}
m_Handle = KeyFromBytes(m_Provider, algorithm, buffer);
}
public ResumptionProvider(int historySize, CryptoProvider provider)
{
_historySize = historySize;
_keyset = new ResumptionKey[_historySize];
_provider = provider;
GenerateResumptionKey();
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var userAccount = await _userService.GetUser(model.Login);
if (userAccount != null)
{
ModelState.AddModelError("", "Пользователь с таким логином уже существует");
}
else
{
model.Password = CryptoProvider.GetMD5Hash(model.Password);
await _userService.AddUser(_mapper.Map <UserDTO>(
new UserViewModel {
Login = model.Login, Name = model.Name, Password = model.Password, Role = Models.Role.User
}));
var userId = await _userService.GetUserId(model.Login);
if (userId != null)
{
Session["userLogin"] = await _userService.GetUserId(model.Login);
FormsAuthentication.SetAuthCookie(Models.Role.User.ToString(), true);
return(RedirectToAction("Index", "Home"));
}
}
}
return(View(model));
}
EncryptedPackageEnvelope(
Stream envelopeStream,
PublishLicense publishLicense,
CryptoProvider cryptoProvider
)
{
if (envelopeStream == null)
{
throw new ArgumentNullException("envelopeStream");
}
ThrowIfRMEncryptionInfoInvalid(publishLicense, cryptoProvider);
_root = StorageRoot.CreateOnStream(envelopeStream, _defaultFileModeForCreate);
//
// CreateOnStream opens the stream for read access if it's readable, and for
// read/write access if it's writable. We're going to need it to be writable,
// so check that it is.
//
if (_root.OpenAccess != FileAccess.ReadWrite)
{
throw new NotSupportedException(SR.StreamNeedsReadWriteAccess);
}
InitializeRMForCreate(publishLicense, cryptoProvider);
EmbedPackage(null);
}
public static string Login(string addr, string login, string password)
{
var msgError = Connect(addr);
if (msgError != null)
{
return(msgError);
}
var logMsg = "Login: "******"Chat " + logMsg);
My = null;
var pass = new CryptoProvider().GetHash(password);
var connect = SessionClient.Get;
if (!connect.Login(login, pass))
{
logMsg = "Login fail: " + connect.ErrorMessage;
Loger.Log("Chat " + logMsg);
MessageBox.Show(connect.ErrorMessage, "Login fail");
//Close();
return(connect.ErrorMessage);
}
else
{
logMsg = "Login OK";
Loger.Log("Chat " + logMsg);
InitConnected();
}
return(null);
}
EncryptedPackageEnvelope(
string envelopeFileName,
Stream packageStream,
PublishLicense publishLicense,
CryptoProvider cryptoProvider
)
{
if (envelopeFileName == null)
{
throw new ArgumentNullException("envelopeFileName");
}
if (packageStream == null)
{
throw new ArgumentNullException("packageStream");
}
ThrowIfRMEncryptionInfoInvalid(publishLicense, cryptoProvider);
_root = StorageRoot.Open(
envelopeFileName,
_defaultFileModeForCreate,
_defaultFileAccess,
_defaultFileShare
);
InitializeRMForCreate(publishLicense, cryptoProvider);
EmbedPackage(packageStream);
}
public string Login(IPEndPoint addr, string login, string password)
{
var msgError = Connect(addr);
if (msgError != null)
{
return(msgError);
}
var logMsg = "Login: "******"Chat " + logMsg);
My = null;
var pass = new CryptoProvider().GetHash(password);
if (!_sessionClient.Login(login, pass, null))
{
logMsg = "Login fail: " + _sessionClient.ErrorMessage;
Loger.Log("Chat " + logMsg);
return(_sessionClient.ErrorMessage);
}
InitConnected();
_modelUpdateTime.Time = DateTime.MinValue;
_modelUpdateTime.Value = 0;
return(null);
}
public void Dispose()
{
CryptoProvider.Dispose();
SocketStream.Dispose();
socket.Dispose();
GC.SuppressFinalize(this);
}
/// <summary>
/// Contructor por defecto.
/// </summary>
/// <param name="alg">Proveedor (algoritmo) seleccionado.</param>
/// <param name="action">Acción a realizar.</param>
internal CryptoServiceProvider(CryptoProvider alg, CryptoAction action)
{
// asignamos las opciones seleccionadas.
// proveedor (algoritmo) de encripción y acción a realizar.
this.algorithm = alg;
this.cAction = action;
}
protected void Page_Load(object sender, EventArgs e)
{
try
{
if (!IsPostBack && !IsCallback)
{
int QuestionnaireID = 0;
securityAgent = new CryptoProvider();
if (Request.QueryString.Count > 0)
{
QuestionnaireID = int.Parse(securityAgent.decryptText(Request.QueryString["QID"].Replace(' ', '+')));
//QuestionnaireID = int.Parse(Request.QueryString["QID"]);
ViewState["CurrentQuestionnaire"] = QuestionnaireID;
}
LoadQuestionnaireList();
AnswerListGridView.DataBind();
if (QuestionnaireID > 0)
{
ConfigGridView.DataBind();
QuestionsGridView.DataBind();
}
}
}
catch (Exception ex)
{
CommonHelpers.writeLogToFile("Page_Load: EditQuestionnaire.aspx", ex.Message);
}
}
public void ValidateCipherTest()
{
var cipher1 = new CipherStub("cipherStub1");
var cipher2 = new CipherStub("cipherStub2");
var cipher3 = new FernetCipher("Fernet cipher");
using var provider = new CryptoProvider(cipher1);
provider.RegisterCipher(cipher2)
.RegisterCipher(cipher3);
var customEncryptionKey =
new CustomEncryptionKey(1, Encoding.UTF8.GetBytes("Custom Encryption Key 32 symbols"));
provider.ValidateCustomCiphers(new SecretsData(new List <Secret> {
customEncryptionKey
},
customEncryptionKey));
Assert.IsNotNull(provider);
var encryptionSecret = new EncryptionSecret(2, Encoding.UTF8.GetBytes("EncryptionSecret"));
provider.ValidateCustomCiphers(new SecretsData(new List <Secret> {
customEncryptionKey, encryptionSecret
},
encryptionSecret));
Assert.IsNotNull(provider);
}
public void RegisterCipherTest()
{
var cipher1 = new CipherStub("cipherStub1");
var cipher2 = new CipherStub("cipherStub2");
using var provider = new CryptoProvider(cipher1);
provider.RegisterCipher(cipher2);
var ex = Assert.Throws <StorageClientException>(() => provider.RegisterCipher(cipher1));
Assert.AreEqual("Custom cipher with name cipherStub1 is already registered", ex.Message);
ex = Assert.Throws <StorageClientException>(() => provider.UnregisterCipher(cipher1));
Assert.AreEqual("Can't unregister default cipher with name cipherStub1", ex.Message);
var unregisterStatus2 = provider.UnregisterCipher(cipher2);
Assert.IsTrue(unregisterStatus2);
var unregisterStatus4 = provider.UnregisterCipher(cipher2);
Assert.IsFalse(unregisterStatus4);
var unregisterStatus5 = provider.UnregisterCipher(null);
Assert.IsFalse(unregisterStatus5);
var unregisterStatus6 = provider.UnregisterCipher(new CipherStub(""));
Assert.IsFalse(unregisterStatus6);
}
private void button1_Click(object sender, EventArgs e)
{
//if (this.username == null || this.password == null)
//{
// MessageBox.Show("Ne postoji konfiguracioni fajl!");
// return;
//}
Korisnik k = PersistanceManager.ReadKorisnik(tbUserName.Text);
if (k == null)
{
MessageBox.Show("Neispravno korisničko ime!");
return;
}
string b = CryptoProvider.CalculateMD5Hash(this.tbPassword.Text);
if (k.Lozinka.ToUpper() == b.ToUpper() && this.tbUserName.Text == k.KorisnickoIme)
{
PersistanceManager.SetKorisnik(k);
base.DialogResult = DialogResult.OK;
base.Close();
return;
}
MessageBox.Show("Neispravno korisničko ime i lozinka!");
}
/// <summary>
/// Initializes a new instance of the SymmetricKey class.
/// </summary>
/// <param name="provider">One of the <see cref="CryptoProvider"/> values.</param>
/// <exception cref="SecurityException">An error occurs when acquiring the cryptographic context.</exception>
private SymmetricKey(CryptoProvider provider) : this(false) {
m_Provider = CAPIProvider.Handle;
/* if (SspiProvider.CryptAcquireContext(ref m_Provider, IntPtr.Zero, null, (int)provider, SecurityConstants.CRYPT_NEWKEYSET) == 0 && Marshal.GetLastWin32Error() == SecurityConstants.NTE_EXISTS) {
if (SspiProvider.CryptAcquireContext(ref m_Provider, IntPtr.Zero, null, (int)provider, 0) == 0)
throw new SecurityException("Cannot acquire crypto service provider.");
}*/
m_ExponentOfOne = CreateExponentOfOneKey();
m_PaddingMode = PaddingMode.None;
}
/// <summary>
/// Initializes a new instance of the SymmetricKey class.
/// </summary>
/// <param name="provider">One of the <see cref="CryptoProvider"/> values.</param>
/// <param name="algorithm">One of the <see cref="CryptoAlgorithm"/> values.</param>
/// <param name="buffer">An array of bytes that contains the key to import.</param>
public SymmetricKey(CryptoProvider provider, CryptoAlgorithm algorithm, byte[] buffer) : this(provider) {
if (buffer == null)
throw new ArgumentNullException();
m_Handle = KeyFromBytes(m_Provider, algorithm, buffer);
}
public static void ParseFiles()
{
if (Application.isEditor)
Compress();
string basePath = Application.dataPath;
string[] mods = Directory.GetFiles(basePath + "/mods", "*.xml");
CryptoProvider crypto = new CryptoProvider();
MemoryStream baseData = crypto.DecryptFileToStream(basePath + "/BaseData.Data", "Rens");
m_dataFile = ZipFile.Read(baseData);
foreach (string name in mods)
{
ParseXML(name, false);
}
foreach (ZipEntry entry in m_dataFile)
{
if (entry.FileName.EndsWith(".xml"))
{
ParseXML(entry.FileName, true);
}
}
ParseUnitHashes();
}
/// <summary>
/// Initializes a new instance of the SymmetricKey class.
/// </summary>
/// <param name="provider">One of the <see cref="CryptoProvider"/> values.</param>
/// <param name="algorithm">One of the <see cref="CryptoAlgorithm"/> values.</param>
/// <exception cref="SecurityException">An error occurs when generating a new key.</exception>
public SymmetricKey(CryptoProvider provider, CryptoAlgorithm algorithm) : this(provider) {
m_Handle = 0;
if (SspiProvider.CryptGenKey(m_Provider, new IntPtr((int)algorithm), SecurityConstants.CRYPT_EXPORTABLE, ref m_Handle) == 0)
throw new SecurityException("Cannot generate session key.");
}
public static void Compress()
{
string basePath = Application.dataPath;
ZipFile zip = new ZipFile();
zip.AddDirectory(basePath + "/BaseData/");
zip.Save(basePath + "/BaseData.Data.temp");
CryptoProvider crypto = new CryptoProvider();
crypto.EncryptFile(basePath + "/BaseData.Data.temp", basePath + "/BaseData.Data", "Rens");
File.Delete(basePath + "/BaseData.Data.temp");
}
