public string OpenConnection(string usernName, string password)
{
string sConnection = "";
Rijndael oRijndael;
oRijndael = new Rijndael();
string oUserName = oRijndael.Decrypt(usernName);
string oUserPwd = oRijndael.Decrypt(password);
sConnection = oConnectionManager.OpenUserConnect(oUserName, oUserPwd);
return(sConnection);
}
public async Task <ActionResult> ResetPassword(User model)
{
try
{
model.Email = Rijndael.Decrypt(model.Email.Replace('-', '+').Replace('_', '/'));
User _user = await db.Users.FirstOrDefaultAsync(c => c.Email == model.Email && c.IsDataActive);
if (_user != null)
{
byte[] _authString = AppManager.GetAuthstring(model.Email, model.Password);
_user.AuthString = _authString;
_user.LastUpdatedOn = AppManager.Now;
await db.SaveChangesAsync();
TempData["Notification"] = new Notification("Success", "Password has been changed successfully.");
return(RedirectToAction("Index"));
}
else
{
TempData["Notification"] = new Notification("Error", "Sorry, we are unable to process your request. Please try again later.");
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
ExceptionHandler.Handle(ex);
TempData["Notification"] = new Notification("Error", "Sorry, we are unable to process your request. Please try again later.");
return(RedirectToAction("Index"));
}
}
private void bGo_Click(object sender, EventArgs e)
{
try
{
//Make sure that we have a value
if (string.IsNullOrWhiteSpace(tSourceString.Text))
{
throw new ApplicationException("No source string provided.");
}
Rijndael rijndael = new Rijndael(_key, _iv);
string input = tSourceString.Text.Trim();
string output;
if (rbEncrypt.Checked)
{
output = rijndael.Encrypt(input);
}
else
{
output = rijndael.Decrypt(tSourceString.Text);
}
tOutputString.Text = output;
}
catch (Exception ex)
{
DisplayError(ex.Message);
}
}
/// <summary>
/// Decrypt the incoming password using the Rijndael algorithm.
/// </summary>
/// <param name="passwordData">Password as byte array</param>
/// <returns></returns>
private string DecryptPassword(byte[] passwordData)
{
var encryptionKey = this.Server.LoginConfiguration.EncryptionKey;
var key = Encoding.ASCII.GetBytes(encryptionKey).Concat(Enumerable.Repeat((byte)0, 5).ToArray()).ToArray();
return(Rijndael.Decrypt(passwordData, key).Trim('\0'));
}
private void button2_Click(object sender, EventArgs e)
{
string key = keyBox.Text.PadRight(16, ' ');
int numBlocks = ciphertextBox.Text.Length / 16 + 1;
plaintextBox.Text = Rijndael.Decrypt(ciphertextBox.Text.PadRight(16 * numBlocks, '\0'), key);
}
/// <summary>
/// Constructor which takes the connection string name
/// </summary>
/// <param name="connectionStringName"></param>
public OracleDatabase(string connectionString)
{
Rijndael oRijndael = new Rijndael();
ResourceFileManager resourceFileManager = null;
resourceFileManager = ResourceFileManager.Instance;
resourceFileManager.SetResources();
if (resourceFileManager.getConfigData("isTest") == "SI")
{
_connection = new OracleConnection(oRijndael.Decrypt(resourceFileManager.getConfigData(connectionString)));
}
else
{
_connection = new OracleConnection(oRijndael.Decrypt(resourceFileManager.getConfigData("ConnectionStringProd")));
}
}
public static Guid?DecryptNullableId(string id)
{
if (string.IsNullOrWhiteSpace(id))
{
return(null);
}
return(Guid.ParseExact(Rijndael.Decrypt(id, SADFM.Base.Constants.IdKey), "N"));
}
/// <summary>
/// 解密
/// </summary>
/// <param name="KeyPath"></param>
/// <param name="data"></param>
/// <returns></returns>
public byte[] DecryptVideo(string KeyPath, byte[] data)
{
Rijndael rij = new Rijndael();
RijndaelKey rijKey = rij.GetKeyAndIV(KeyPath);
return(rij.Decrypt(data, rijKey.key, rijKey.IV));
}
//---------------------------------------------------------------
public void LoadData()
{
byte[] soupBackIn = File.ReadAllBytes(filename);
string jsonFromFile = crypto.Decrypt(soupBackIn, JSON_ENCRYPTED_KEY);
SaveData copy = JsonUtility.FromJson <SaveData>(jsonFromFile);
Debug.Log(copy.health);
}
public void RandomIv256()
{
var ciphertext1 = Rijndael.Encrypt(Plaintext, Password, KeySize.Aes256);
var ciphertext2 = Rijndael.Encrypt(Plaintext, Password, KeySize.Aes256);
var plaintext = Rijndael.Decrypt(ciphertext1, Password, KeySize.Aes256);
Assert.Equal(plaintext, Plaintext);
Assert.NotEqual(ciphertext1, ciphertext2);
}
public async Task <ActionResult> Dashboard()
{
var _response = await Client.GetAddressBalancesAsync(Rijndael.Decrypt(AppManager.User.BCHash));
ViewBag.Response = _response.Result;
ViewBag.RecentTransactions = (await Client.ListAddressTransactionsAsync(Rijndael.Decrypt(AppManager.User.BCHash), 100)).Result.Where(i => i.balance.assets != null).OrderByDescending(i => i.time).Take(10).ToList();
ViewBag.Requests = await db.Requests.Include(r => r.User).Where(r => r.IsDataActive && r.SenderID == AppManager.User.ID || r.Recipient == AppManager.User.Email || r.Recipient == AppManager.User.NickName).OrderByDescending(r => r.ID).Take(10).ToListAsync();
return(View(await db.Users.FirstOrDefaultAsync(u => u.ID == AppManager.User.ID)));
}
public async Task <ActionResult> Send()
{
ViewBag.Asset = (await Client.GetAddressBalancesAsync(Rijndael.Decrypt(AppManager.User.BCHash))).Result.Select(i => new SelectListItem
{
Text = $"{i.Name} ({i.Qty} available in wallet)",
Value = i.AssetRef
});
return(View());
}
public static XmlNode DecryptNode(XmlNode encryptedNode)
{
string decryptedData = Rijndael.Decrypt(encryptedNode.InnerText, key, KeySize.Aes256);
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.PreserveWhitespace = true;
xmlDoc.LoadXml(decryptedData);
return(xmlDoc.DocumentElement);
}
public string Decrypt(string text)
{
string textPlan = "";
if (text != null)
{
textPlan = Rijndael.Decrypt(text, _password, KeySize.Aes256);
}
return(textPlan);
}
public async Task <ActionResult> Issue(Asset model)
{
if (ModelState.IsValid)
{
var _recipient = await db.Users.FirstOrDefaultAsync(u => u.Email == model.Address && u.IsDataActive);
if (_recipient != null && !string.IsNullOrEmpty(_recipient.BCHash))
{
if (!string.IsNullOrEmpty(Request.QueryString["asset_name"]))
{
var _duplicateAssets = (await Client.ListAssetsAsync(model.Name)).Result;
var _response = await Client.IssueMoreAsync(Rijndael.Decrypt(_recipient.BCHash), model.Name, model.Quantity);
if (string.IsNullOrEmpty(_response.Error))
{
TempData["Notification"] = new Notification("Success", $"More quantity of {model.Name} has been issued successfully");
}
else
{
TempData["Notification"] = new Notification("Error", _response.Error);
}
}
else
{
object _asset = new
{
name = model.Name,
open = true
};
var _response = await Client.IssueAsync(Rijndael.Decrypt(_recipient.BCHash), _asset, model.Quantity, model.Units);
if (string.IsNullOrEmpty(_response.Error))
{
TempData["Notification"] = new Notification("Success", "New Asset has been created successfully");
}
else
{
TempData["Notification"] = new Notification("Error", _response.Error);
}
}
}
else
{
TempData["Notification"] = new Notification("Error", "Invalid Recipient. Please try again later.");
}
}
else
{
TempData["Notification"] = new Notification("Error", "One or more required fields are missing. Please try again later.");
}
return(Redirect("/Assets/Index"));
}
/// <summary>
/// Recebe um texto criptografado e retorna uma string em texto plano.
/// </summary>
/// <param name="textoCriptografado"></param>
/// <returns></returns>
public static string Descriptografar(string textoCriptografado)
{
string textoPlano = "";
if (textoCriptografado != null)
{
textoPlano = Rijndael.Decrypt(textoCriptografado, password, KeySize.Aes256);
}
return(textoPlano);
}
/// <summary>
/// Receives an encrypted text and returns a plain text string
/// </summary>
/// <param name="textEncrypted"></param>
/// <returns></returns>
public static string Decrypt(string textEncrypted)
{
string textPlan = "";
if (textEncrypted != null)
{
textPlan = Rijndael.Decrypt(textEncrypted, password, KeySize.Aes256);
}
return(textPlan);
}
public void Desencriptar()
{
this._pgsqlhost = _rij.Decrypt(this._pgsqlhost);
this._pgsqlport = _rij.Decrypt(this._pgsqlport);
this._pgsqldb = _rij.Decrypt(this._pgsqldb);
this._pgsqlusr = _rij.Decrypt(this._pgsqlusr);
this._pgsqlpwd = _rij.Decrypt(this._pgsqlpwd);
this._pgsqlCmdTimeOut = _rij.Decrypt(this._pgsqlCmdTimeOut);
this._perfil = _rij.Decrypt(this._perfil);
}
public void dataload()
{
Rijndael crypto = new Rijndael();
string filename = Path.Combine(Application.persistentDataPath, SAVE_FILE);
byte[] soupBackIn = File.ReadAllBytes(filename);
string jsonFromFile = crypto.Decrypt(soupBackIn, JSON_ENCRYPTED_KEY);
SaveData copy = JsonUtility.FromJson <SaveData>(jsonFromFile);
scorevalue = copy.scorevalue;
Debug.Log(copy.scorevalue);
}
public async Task <ActionResult> Signup(User model)
{
model.ConfirmPassword = model.Password;
ModelState.Clear();
TryValidateModel(model);
if (ModelState.IsValid)
{
if (!await db.Users.AnyAsync(u => (u.Email == model.Email || u.Username.ToLower() == model.Username.ToLower()) && u.IsDataActive))
{
try
{
model.AuthString = Rijndael.Encrypt(string.Concat(model.Username.ToLower(), model.Password));
model.CreatedOn = model.LastUpdatedOn = DateTime.Now;
model.Username = model.Username.ToLower();
model.IsDataActive = true;
model.IsSearchable = false;
db.Users.Add(model);
await db.SaveChangesAsync();
model.BCHash = await AppManager.CreateAddress();
await db.SaveChangesAsync();
await Client.IssueMoreAsync(Rijndael.Decrypt(model.BCHash), "Seratio Coin", 1000);
string _body = $"Hello {(model.NickName != null ? model.NickName : "@" + model.Username.ToLower())} ,<br /><br />Welcome to Seratio Blockchain.<br />We have added 1000 Seratio Coins to your wallet for you to get started with our Platform.";
AppManager.SendEmail("Welcome to Seratio Blockchain", model.Email, _body);
TempData["Notification"] = new Notification("Success", "Welcome to Seratio Blockchain, your account has been created successfully.");
return(RedirectToAction("index"));
}
catch (DbEntityValidationException ex)
{
string _errorMessages = string.Join("; ", ex.EntityValidationErrors.SelectMany(x => x.ValidationErrors).Select(x => x.ErrorMessage));
TempData["Notification"] = new Notification("Error", _errorMessages);
}
}
else
{
TempData["Notification"] = new Notification("Error", "There is an existing account associated with this email or Username.");
}
}
else
{
TempData["Notification"] = new Notification("Error", "One or more required fields are missing. Please try again later.");
}
return(View(model));
}
public IVersion GetLocalVersion()
{
if (FilesManager.Exists(Settings.GetVersionFilePath()))
{
var encryptedVersion = File.ReadAllText(Settings.GetVersionFilePath());
var decryptedVersion = Rijndael.Decrypt(encryptedVersion, Settings.EncryptionKeyphrase);
return(Serializer.Deserialize <IVersion>(decryptedVersion));
}
else
{
return(null);
}
}
private ZPrincipal GetPrincipal(HttpActionContext actionContext)
{
try
{
string authHeader = actionContext.Request.Headers.GetValues(AuthConfiguration.AuthHeader).First();
var result = Rijndael.Decrypt(authHeader, Rijndael.GetRandomKeyText());
return(JsonConvert.DeserializeObject <ZPrincipal>(result));
}
catch (Exception)
{
return(null);
}
}
public static async Task <ProfileData> LoadProfileAsync(string path, string profileName, string profileId)
{
// This is the encrypted input from the file
byte[] soupBackIn = await AsyncHelperExtensions.ReadBytesAsync(path);
// Creates the unique Encryption key per profile
string jsonEncryptedKey = $"{profileName}BXRB98y-h^4^.ct^]~8|Cmn5([]+/+{profileName}@&";
// If the key is shorter then 32 characters it will make it longer
if (jsonEncryptedKey.Length < 33)
{
while (jsonEncryptedKey.Length < 33)
{
jsonEncryptedKey = $"{profileName}BXRB98y-h^4^.ct^]~8|Cmn5([-+/{profileName}@&{profileName}";
}
}
// If the value is longer then 32 characters it will make it 32 characters
if (jsonEncryptedKey.Length > 32)
{
jsonEncryptedKey = jsonEncryptedKey.Truncate(32);
}
// Decrypting process
Rijndael crypto = new Rijndael();
string jsonFromFile = crypto.Decrypt(soupBackIn, jsonEncryptedKey);
// Creates a ProfileData object with the information from the json file
ProfileData profile = JsonUtility.FromJson <ProfileData>(jsonFromFile);
// Checks if the decrypted Profile Data is null or not
if (profile == null)
{
Debug.Log("Failed to load profile");
return(null);
}
if (profile.fullProfileName != profileName)
{
Debug.Log("Profile Name's are not matching");
return(null);
}
if (profile.profileId != profileId)
{
Debug.Log("Profile ID's are not matching");
return(null);
}
SaveManagerEvents.current.ProfileLoaded(profile);
return(profile);
}
public static async Task LoadAllProfilesAsync(string path)
{
// This is the encrypted input from the file
byte[] soupBackIn = await AsyncHelperExtensions.ReadBytesAsync(path);
// Decrypting process
Rijndael crypto = new Rijndael();
string jsonFromFile = crypto.Decrypt(soupBackIn, JsonEncryptedKeyProfiles);
ProfilesListWrapper profiles = JsonUtility.FromJson <ProfilesListWrapper>(jsonFromFile);
SaveManager.profiles = profiles == null ? new List <ProfilesData>() : profiles.Profiles;
SaveManagerEvents.current.AllProfilesLoaded(SaveManager.profiles);
}
private void SetCurrentVersion()
{
if (FilesManager.Exists(Settings.GetVersionFilePath()))
{
var encryptedVersion = File.ReadAllText(Settings.GetVersionFilePath());
var decryptedVersion = Rijndael.Decrypt(encryptedVersion, Settings.EncryptionKeyphrase);
CurrentVersion = Serializer.Deserialize <IVersion>(decryptedVersion);
Logger.Info("Retrieved current version: {CurrentVersion}", CurrentVersion);
}
else
{
CurrentVersion = null;
Logger.Warning("No current version found. A full repair may be required.");
}
}
// Use this for initialization
void Start()
{
byte[] bytes = new byte[4] {
100, 99, 98, 97
};
RijndaelManaged rijma = new RijndaelManaged();
rijma.GenerateKey();
rijma.GenerateIV();
Rijndael rij = new Rijndael();
byte[] enbytes = rij.Encrypt(bytes, rijma.Key, rijma.IV);
byte[] debytes = rij.Decrypt(enbytes, rijma.Key, rijma.IV);
}
public bool ValidateApplicationToken(string appId, string appToken)
{
if (string.IsNullOrWhiteSpace(appId) || string.IsNullOrWhiteSpace(appToken))
{
return(false);
}
var appAuth = _applicationAuthenticationRepository.GetByAppIdAndTokenId(Rijndael.Decrypt(appId), Rijndael.Decrypt(appToken));
if (appAuth != null)
{
return(true);
}
return(false);
}
public static object openPackage(byte[] package)
{
package = Rijndael.Decrypt(package);
byte[] packetdata;
if (package[0] != 255 || package[package.Length - 1] != 255)
{
throw new NotImplementedException();
}
packetdata = trimMessage(package);
switch (package[1])
{
case (byte)DATATYPE.INT:
byte tmp = packetdata[0];
return(Convert.ToInt32(tmp));
case (byte)DATATYPE.DOUBLE:
tmp = packetdata[0];
return(Convert.ToDouble(tmp));
case (byte)DATATYPE.STRING:
return(Encoding.ASCII.GetString(packetdata));
case (byte)DATATYPE.CPU:
return(JsonConvert.DeserializeObject <CPU>(Encoding.ASCII.GetString(packetdata)));
case (byte)DATATYPE.OS:
return(JsonConvert.DeserializeObject <OS>(Encoding.ASCII.GetString(packetdata)));
case (byte)DATATYPE.DISK:
return(JsonConvert.DeserializeObject <Disk>(Encoding.ASCII.GetString(packetdata)));
case (byte)DATATYPE.NETWORK:
throw new NotImplementedException();
//ToDo: NotImplemented
case (byte)DATATYPE.RAM:
return(JsonConvert.DeserializeObject <RAM>(Encoding.ASCII.GetString(packetdata)));
case (byte)DATATYPE.MAINBOARD:
return(JsonConvert.DeserializeObject <Mainboard>(Encoding.ASCII.GetString(packetdata)));
}
return(null);
}
private void AssignConnectionString()
{
//Attempt to retrieve the connection string from the web.config file
ConnectionStringSettings connStrSettings;
if ((connStrSettings = ConfigurationManager.ConnectionStrings["MsSqlRepository"]) == null)
{
throw new ConnectionStringAssignmentException();
}
//We expect the connection string to be encrypted, so decrypt it
string encryptedConnStr = connStrSettings.ConnectionString;
Rijndael rijndael = new Rijndael(_key, _iv);
_connectionString = rijndael.Decrypt(encryptedConnStr);
}
// Load Game
public static async Task <GameData> LoadGameAsync()
{
if (SelectedProfileManager.selectedProfile == null)
{
return(null);
}
string fullProfileName = SelectedProfileManager.selectedProfile.fullProfileName;
string path = Path.Combine(MainDirectoryPath, fullProfileName, "Save", "data.dat");
if (!File.Exists(path))
{
return(null);
}
// This is the encrypted input from the file
byte[] soupBackIn = await AsyncHelperExtensions.ReadBytesAsync(path);
// Creates the unique Encryption key per profile
string jsonEncryptedKey = "|9{Ajia:p,g<ae&)9KsLy7;<t9G5sJ>G";
// If the value is longer then 32 characters it will make it 32 characters
if (jsonEncryptedKey.Length > 32)
{
jsonEncryptedKey = jsonEncryptedKey.Truncate(32);
}
// Decrypting process
Rijndael crypto = new Rijndael();
string jsonFromFile = crypto.Decrypt(soupBackIn, jsonEncryptedKey);
// Creates a ProfileData object with the information from the json file
GameData gameData = JsonUtility.FromJson <GameData>(jsonFromFile);
// Checks if the decrypted Profile Data is null or not
if (gameData == null)
{
Debug.Log("Failed to load game data.");
return(null);
}
SaveManagerEvents.current.LoadGame(gameData, SelectedProfileManager.selectedProfile);
return(gameData);
}
private static void CryptoTest()
{
var serializer = new BinaryFormatter(Encoding.Unicode);
var tripleDes = new Rijndael();
var model = GenerateRelatedModel();
var bytes = serializer.Serialize(model);
var enc = tripleDes.Encrypt(bytes);
var dec = tripleDes.Decrypt(enc);
var des = serializer.Deserialize(dec);
var enc2 = tripleDes.Encrypt(bytes);
var dec2 = tripleDes.Decrypt(enc2);
}
public string Decode(byte[] bytesToDecode)
{
Rijndael decoder = new Rijndael(Key);
return decoder.Decrypt(bytesToDecode);
}