/// <summary>
/// Takes the given text and encrypts it using the given password.
/// </summary>
/// <param name="textToEncrypt">Text to encrypt.</param>
/// <param name="encryptionPassword">Encryption password.</param>
/// <returns>The encrypted text.</returns>
public static string Encrypt(
string textToEncrypt, string encryptionPassword)
{
return(AESGCM.SimpleEncryptWithPassword(
textToEncrypt, encryptionPassword));
}
/// <summary>
/// Takes the given encrypted text and decrypts it
/// using the given password.
/// </summary>
/// <param name="encryptedText">Encrypted text.</param>
/// <param name="encryptionPassword">Encryption password.</param>
/// <returns>The decrypted text.</returns>
public static string Decrypt(
string encryptedText, string encryptionPassword)
{
return(AESGCM.SimpleDecryptWithPassword(
encryptedText, encryptionPassword));
}
public static void ImportEmailFile()
{
Log.Append("Application initialized");
TimeSpan startTime = DateTime.Now.TimeOfDay;
Log.Append("Caching email list...");
try
{
string[] emailFiles = Directory.GetFiles(cacheDirectoryPath, "*.cfg*");
if (emailFiles.Length <= 0)
{
RegenerateCacheFile();
}
foreach (string filePath in emailFiles)
{
var text = File.ReadAllText(filePath);
string[] lines = AESGCM.SimpleDecryptWithPassword(text, AESGCM.AES256Key)
.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
// Load email information
foreach (string line in lines)
{
if (line.Contains("[EM_ID_]="))
{
Email email = new Email()
{
ID = Parser.Parse(line, "EM_ID_"),
UID = Parser.Parse(line, "EM_UI_"),
To = Parser.Parse(line, "EM_TO_"),
From = Parser.Parse(line, "EM_FR_"),
Subject = Parser.Parse(line, "EM_SU_"),
EmailMessage = "", // prevent nullification
MailDate = Convert.ToDateTime(Parser.Parse(line, "EM_MD_"))
};
// For testing, local does not read emails
//email.RetrieveMsg();
EmailList.Add(email);
email.MapNameFromEmail();
}
}
}
}
catch (Exception e)
{
RegenerateCacheFile();
}
// Retrieve all messages in background
Task.Run(() => ReadAllEmailMessages());
// Sort by date
EmailList = EmailList.OrderByDescending(x => x.MailDate).ToList();
Log.Append(String.Format("Cached {1} emails! Process took {0}",
Arithmetic.GetStopWatchStr((DateTime.Now.TimeOfDay - startTime).TotalMilliseconds), EmailList.Count));
GetEmailCounts();
}
public Contracts.JobTypes.Ftp.Model.FtpDownloadJob Get(Guid id)
{
Logger.Debug("Entered FtpJobsController.Get().");
IJobDetail jobDetail;
try
{
jobDetail = _schedulerCore.GetJobDetail(id);
}
catch (Exception ex)
{
Logger.WarnFormat("Error getting JobDetail: {0}", ex.Message);
return(null);
}
string username = jobDetail.JobDataMap.GetString("userName");
string password = jobDetail.JobDataMap.GetString("password");
string sshPrivateKeyPassword = jobDetail.JobDataMap.GetString("sshPrivateKeyPassword");
try
{
if (new EncryptionFeatureToggle().FeatureEnabled)
{
username = AESGCM.SimpleDecrypt(username, Convert.FromBase64String(ConfigurationManager.AppSettings["SchedulerEncryptionKey"]));
if (!string.IsNullOrEmpty(password))
{
password = AESGCM.SimpleDecrypt(password, Convert.FromBase64String(ConfigurationManager.AppSettings["SchedulerEncryptionKey"]));
}
if (!string.IsNullOrEmpty(sshPrivateKeyPassword))
{
sshPrivateKeyPassword = AESGCM.SimpleDecrypt(sshPrivateKeyPassword, Convert.FromBase64String(ConfigurationManager.AppSettings["SchedulerEncryptionKey"]));
}
}
}
catch (Exception ex)
{
Logger.Warn("ConfigurationError getting FtpDownload job.", ex);
}
return(new Contracts.JobTypes.Ftp.Model.FtpDownloadJob
{
Id = id,
JobName = jobDetail.Key.Name,
JobGroup = jobDetail.Key.Group,
SchedulerName = _schedulerCore.SchedulerName,
FtpHost = jobDetail.JobDataMap.GetString("ftpHost"),
ServerPort = jobDetail.JobDataMap.GetString("serverPort"),
Username = username,
Password = password,
LocalDirectoryPath = jobDetail.JobDataMap.GetString("localDirectoryPath"),
RemoteDirectoryPath = jobDetail.JobDataMap.GetString("remoteDirectoryPath"),
FileExtensions = jobDetail.JobDataMap.GetString("fileExtensions"),
CutOffTimeSpan = jobDetail.JobDataMap.GetString("cutOffTimeSpan"),
Description = jobDetail.Description,
SshPrivateKeyPath = jobDetail.JobDataMap.GetString("sshPrivateKeyPath"),
SshPrivateKeyPassword = sshPrivateKeyPassword
});
}
public IActionResult Post(object encryptObject)
{
using (var dbContextTransaction = _dbContext.Database.BeginTransaction())
{
try
{
IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers;
string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault();
if (string.IsNullOrEmpty(accessToken))
{
return(BadRequest("Invalid Authorization"));
}
accessToken = accessToken.Substring(7);
string jsonString = AESGCM.Decrypt(encryptObject.ToString(), accessToken);
ApplicationUser input = JsonConvert.DeserializeObject <ApplicationUser>(jsonString);
ApplicationUser user = _dbContext.Users
.Include("Claims")
.Include("Logins")
.Include("Tokens")
.Include("RoleClaims")
//.Include("RoleClaims.User")
.Include("RoleClaims.Role")
.Include("RoleClaims.RoleClaim")
.Include("RoleClaims.History")
.Include("RoleClaims.History.ActionBy")
//.Include("RoleClaims.History.UserRoleClaim")
.Where(x => x.Id == input.Id)
.FirstOrDefault();
if (user != null)
{
if (user.AccessFailedCount != input.AccessFailedCount)
{
user.AccessFailedCount = input.AccessFailedCount;
}
if (user.ApprovedById != input.ApprovedById)
{
user.ApprovedById = input.ApprovedById;
}
if (user.ApprovedDate != input.ApprovedDate)
{
user.ApprovedDate = input.ApprovedDate;
}
if (user.ConcurrencyStamp != input.ConcurrencyStamp)
{
user.ConcurrencyStamp = input.ConcurrencyStamp;
}
if (user.Email != input.Email)
{
user.Email = input.Email;
user.NormalizedEmail = input.Email.Trim().ToUpper();
}
if (user.EmailConfirmed != input.EmailConfirmed)
{
user.EmailConfirmed = input.EmailConfirmed;
}
if (user.UserName != input.UserName)
{
user.UserName = input.UserName;
user.NormalizedUserName = input.UserName.Trim().ToUpper();
}
if (user.FirstName != input.FirstName)
{
user.FirstName = input.FirstName;
}
if (user.LastName != input.LastName)
{
user.LastName = input.LastName;
}
if (user.LockoutEnabled != input.LockoutEnabled)
{
user.LockoutEnabled = input.LockoutEnabled;
}
if (user.LockoutEnd != input.LockoutEnd)
{
user.LockoutEnd = input.LockoutEnd;
}
if (user.PasswordHash != input.PasswordHash)
{
user.PasswordHash = input.PasswordHash;
}
if (user.PhoneNumber != input.PhoneNumber)
{
user.PhoneNumber = input.PhoneNumber;
}
if (user.PhoneNumberConfirmed != input.PhoneNumberConfirmed)
{
user.PhoneNumberConfirmed = input.PhoneNumberConfirmed;
}
if (user.RequestDate != input.RequestDate)
{
user.RequestDate = input.RequestDate;
}
if (user.RevokedById != input.RevokedById)
{
user.RevokedById = input.RevokedById;
}
if (user.RevokedDate != input.RevokedDate)
{
user.RevokedDate = input.RevokedDate;
}
if (user.TwoFactorEnabled != input.TwoFactorEnabled)
{
user.TwoFactorEnabled = input.TwoFactorEnabled;
}
// remove Claims
foreach (IdentityUserClaim <string> userClaim in user.Claims.ToArray())
{
var inputClaim = input.Claims
.Where(x => x.ClaimType.Trim().ToUpper() == userClaim.ClaimType.Trim().ToUpper() && x.ClaimValue.Trim().ToUpper() == userClaim.ClaimValue.Trim().ToUpper())
.FirstOrDefault();
if (inputClaim == null)
{
user.Claims.Remove(userClaim);
_dbContext.Entry(userClaim).State = EntityState.Deleted;
}
}
// add Claims
foreach (IdentityUserClaim <string> inputClaim in input.Claims)
{
var userClaim = user.Claims.ToArray()
.Where(x => x.ClaimType.Trim().ToUpper() == inputClaim.ClaimType.Trim().ToUpper() && x.ClaimValue.Trim().ToUpper() == inputClaim.ClaimValue.Trim().ToUpper())
.FirstOrDefault();
if (userClaim == null)
{
user.Claims.Add(inputClaim);
}
}
// remove Logins
foreach (IdentityUserLogin <string> userLogin in user.Logins.ToArray())
{
var inputLogin = input.Logins
.Where(x => x.LoginProvider.Trim().ToUpper() == userLogin.LoginProvider.Trim().ToUpper() && x.ProviderKey.Trim().ToUpper() == userLogin.ProviderKey.Trim().ToUpper())
.FirstOrDefault();
if (inputLogin == null)
{
user.Logins.Remove(userLogin);
_dbContext.Entry(userLogin).State = EntityState.Deleted;
}
}
// add Logins
foreach (IdentityUserLogin <string> inputLogin in input.Logins)
{
var userLogin = user.Logins.ToArray()
.Where(x => x.LoginProvider.Trim().ToUpper() == inputLogin.LoginProvider.Trim().ToUpper() && x.ProviderKey.Trim().ToUpper() == inputLogin.ProviderKey.Trim().ToUpper())
.FirstOrDefault();
if (userLogin == null)
{
user.Logins.Add(inputLogin);
}
}
// remove Tokens
foreach (IdentityUserToken <string> userToken in user.Tokens.ToArray())
{
var inputToken = input.Tokens
.Where(x => x.LoginProvider.Trim().ToUpper() == userToken.LoginProvider.Trim().ToUpper() && x.Name.Trim().ToUpper() == userToken.Name.Trim().ToUpper() && x.Value.Trim().ToUpper() == userToken.Value.Trim().ToUpper())
.FirstOrDefault();
if (inputToken == null)
{
user.Tokens.Remove(userToken);
_dbContext.Entry(userToken).State = EntityState.Deleted;
}
}
// add Tokens
foreach (IdentityUserToken <string> inputToken in input.Tokens)
{
var userToken = user.Tokens.ToArray()
.Where(x => x.LoginProvider.Trim().ToUpper() == inputToken.LoginProvider.Trim().ToUpper() && x.Name.Trim().ToUpper() == inputToken.Name.Trim().ToUpper() && x.Value.Trim().ToUpper() == inputToken.Value.Trim().ToUpper())
.FirstOrDefault();
if (userToken == null)
{
user.Tokens.Add(inputToken);
}
}
// remove RoleClaims
foreach (AspNetUserRoleClaim userRoleClaim in user.RoleClaims.ToArray())
{
user.RoleClaims.Remove(userRoleClaim);
_dbContext.Entry(userRoleClaim).State = EntityState.Deleted;
}
// add RoleClaims
foreach (AspNetUserRoleClaim inputRoleClaim in input.RoleClaims)
{
var userRoleClaim = user.RoleClaims
.Where(x => x.RoleId == inputRoleClaim.RoleId &&
x.RoleClaimId == inputRoleClaim.RoleClaimId)
.FirstOrDefault();
if (userRoleClaim == null)
{
if (inputRoleClaim.User == null)
{
inputRoleClaim.User = user;
}
foreach (AspNetUserRoleClaimHistory inputHistory in inputRoleClaim.History)
{
if (inputHistory.UserRoleClaim == null)
{
inputHistory.UserRoleClaim = inputRoleClaim;
}
_dbContext.Entry(inputHistory).State = EntityState.Added;
}
user.RoleClaims.Add(inputRoleClaim);
_dbContext.Entry(inputRoleClaim).State = EntityState.Added;
}
}
// save changes
if (_dbContext.HasUnsavedChanges())
{
_dbContext.Users.Update(user);
_dbContext.SaveChanges();
dbContextTransaction.Commit();
}
}
return(Ok());
}
catch (Exception exception)
{
dbContextTransaction.Rollback();
_logger.Exception(exception);
return(BadRequest(exception));
}
}
}
private static void TestLibraries(bool testCompression = true, bool testEncryption = true)
{
var myOrgMsg = "123456";
var encryptedx = AESGCM.SimpleEncryptWithPassword(myOrgMsg, "123456");
var decryptedx = AESGCM.SimpleDecryptWithPassword(encryptedx, "1234567");
try
{
Parallel.For(0, 1000000, i =>
{
var v = new InstructorValidationData($"Std{i}", DateTime.Now, 10, 11);
var serialized = SerializationHelper.Serialize <InstructorValidationData>(v);
if (serialized == null)
{
throw new Exception("serialized==null");
}
string compressedString = Framework_Project.Compression.CompressionHelper.Zip(serialized);
if (compressedString == null)
{
throw new Exception("compressed==null");
}
// string decompressed = Framework_Project.Compression.CompressionHelper.Unzip(compressedString);
string encrypted = AESGCM.SimpleEncryptWithPassword(compressedString, $"Keyyy{i}");
if (encrypted == null)
{
throw new Exception("encrypted==null");
}
string decrypted = AESGCM.SimpleDecryptWithPassword(encrypted, $"Keyyy{i}");
if (decrypted == null)
{
throw new Exception("decrypted==null");
}
if (decrypted != compressedString)
{
throw new Exception("decrypted!=compressedString");
}
if (!StructuralComparisons.StructuralEqualityComparer.Equals(decrypted, compressedString))
{
throw new Exception("decryptedBytes!=compressed");
}
string decompressed = Framework_Project.Compression.CompressionHelper.Unzip(decrypted);
if (decompressed == null)
{
throw new Exception("decompressed==null");
}
if (decompressed != serialized)
{
throw new Exception("decompressed != serialized");
}
var deserialized = SerializationHelper.Deserialize <InstructorValidationData>(serialized);
});
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
//=========================== SYNC SYSTEM =============================
/// <summary>
/// Upload entire information item/order list from FTP/Cloud_Sync/FullSync directory
/// </summary>
public static void DownloadAllInformation()
{
string syncText = "";
string emailAddress = GetSettingsValue("SYNC_EMAIL");
try
{
if (Global.isOnWifi()) // only try on WiFi (most data will block this)
{
List <string> lines = new List <string>();
// Copy local repository to FTP Server
if (Device.OS == TargetPlatform.Android || Device.OS == TargetPlatform.iOS)
{
// Read from FTP File
//string[] lines = GetFileContent(emailAddress + SyncFileName)
lines = AESGCM
.SimpleDecryptWithPassword(
DependencyService.Get <IFtpWebRequest>().FTPRead(emailAddress + FullSyncFileName), AESGCMKey)
.Split(new[] { Environment.NewLine }, StringSplitOptions.None).ToList();
}
// Load items and orders from downloaded file
foreach (string line in lines)
{
// Load items
if (line.Contains("||[IT_LO]="))
{
Item New_Item = new Item();
New_Item.Name = Parse_Line_Information(line, "IT_DE_");
New_Item.Status = Parse_Line_Information(line, "IT_ST_") == "" ? "0" : Parse_Line_Information(line, "IT_ST_");
New_Item.RefundAlert = Parse_Line_Information(line, "IT_RE_") == "1" ? true : false;
New_Item.consumedStatus = Convert.ToInt32(Parse_Line_Information(line, "IT_CO_", "||", "2"));
New_Item.Location = Parse_Line_Information(line, "IT_LO");
New_Item.Payment_Type = Parse_Line_Information(line, "IT_PA_");
New_Item.Category = Parse_Line_Information(line, "IT_CA_");
New_Item.Discount_Amt = Convert.ToDouble(Parse_Line_Information(line, "IT_DI_", "||", "0"));
New_Item.Price = Convert.ToDouble(Parse_Line_Information(line, "IT_PR_"));
New_Item.Quantity = Convert.ToInt32(Parse_Line_Information(line, "IT_QU_"));
New_Item.Date = Convert.ToDateTime(Parse_Line_Information(line, "IT_DA_"));
New_Item.Refund_Date = Parse_Line_Information(line, "IT_RD_").Length > 0 ? Convert.ToDateTime(Parse_Line_Information(line, "IT_RD_")) : DateTime.Now;
New_Item.Memo = Parse_Line_Information(line, "IT_ME_");
New_Item.OrderID = Parse_Line_Information(line, "IT_ID_");
GlobalItemList.Add(New_Item);
}
// Load orders
else if (line.Contains("||[OR_QU_]="))
{
Order New_Order = new Order();
New_Order.Location = Parse_Line_Information(line, "OR_LO_");
New_Order.OrderMemo = Parse_Line_Information(line, "OR_ME_");
New_Order.Payment = Parse_Line_Information(line, "OR_PA_");
New_Order.Tax_Overridden = (Parse_Line_Information(line, "OR_TO_") == "1");
New_Order.Order_Total_Pre_Tax = Convert.ToDouble(Parse_Line_Information(line, "OR_PP_"));
New_Order.GC_Amount = Convert.ToDouble(Parse_Line_Information(line, "OR_GC_", "||", "0"));
New_Order.Order_Taxes = Convert.ToDouble(Parse_Line_Information(line, "OR_TA_"));
New_Order.Order_Discount_Amt = Convert.ToDouble(Parse_Line_Information(line, "OR_DI_", "||", "0"));
New_Order.Order_Quantity = Convert.ToInt32(Parse_Line_Information(line, "OR_QU_"));
New_Order.Date = Convert.ToDateTime(Parse_Line_Information(line, "OR_DA_"));
New_Order.OrderID = Parse_Line_Information(line, "OR_ID_");
GlobalOrderList.Add(New_Order);
}
}
foreach (Item item in GlobalItemList)
{
Debug.WriteLine(item.ToString());
}
}
}
catch (Exception Ex)
{
Debug.WriteLine("No file found: " + Ex);
}
}
/// <summary>
/// Method to store encrypted object in Http Session
/// </summary>
/// <param name="session">ISession</param>
/// <param name="key">string</param>
/// <param name="value">T</param>
/// <method>Encrypt<T>(this ISession session, string key, T value)</method>
public static async void Encrypt <T>(this ISession session, string key, T value)
{
session.SetString(key, AESGCM.Encrypt(JsonSerializer.Serialize(value)));
await session.CommitAsync();
}
public void Execute(IJobExecutionContext context)
{
JobDataMap data = context.MergedJobDataMap;
var jobName = context.JobDetail.Key.Name;
string ftpHost = GetRequiredParameter(data, FtpHost, jobName);
string serverPort = GetOptionalParameter(data, ServerPort);
string userName = GetOptionalParameter(data, UserName);
string password = GetOptionalParameter(data, Password);
string localDirectoryPath = GetRequiredParameter(data, LocalDirectoryPath, jobName);
string remoteDirectoryPath = GetOptionalParameter(data, RemoteDirectoryPath);
string cutOff = GetOptionalParameter(data, CutOff);
string fileExtensions = GetRequiredParameter(data, FileExtensions, jobName);
string sshPrivateKeyPath = GetOptionalParameter(data, SshPrivateKeyPath);
string sshPrivateKeyPassword = GetOptionalParameter(data, SshPrivateKeyPassword);
// Set defaults
int port = (!string.IsNullOrEmpty(serverPort) ? Int32.Parse(serverPort) : 21);
cutOff = (!string.IsNullOrEmpty(cutOff) ? cutOff : "1.00:00:00"); // 1 day
// Validate cutOffTimeSpan format
TimeSpan cutOffTimeSpan;
if (!TimeSpan.TryParse(cutOff, out cutOffTimeSpan))
{
var err = string.Format("Invalid cutOffTimeSpan format [{0}] specified.", cutOff);
Logger.ErrorFormat("Error in FtpDownloadJob ({0}): {1}", jobName, err);
throw new JobExecutionException(err);
}
try
{
if (new EncryptionFeatureToggle().FeatureEnabled)
{
userName = AESGCM.SimpleDecrypt(userName, Convert.FromBase64String(ConfigurationManager.AppSettings["SchedulerEncryptionKey"]));
if (!string.IsNullOrEmpty(password))
{
password = AESGCM.SimpleDecrypt(password, Convert.FromBase64String(ConfigurationManager.AppSettings["SchedulerEncryptionKey"]));
}
if (!string.IsNullOrEmpty(sshPrivateKeyPassword))
{
sshPrivateKeyPassword = AESGCM.SimpleDecrypt(sshPrivateKeyPassword, Convert.FromBase64String(ConfigurationManager.AppSettings["SchedulerEncryptionKey"]));
}
}
}
catch (Exception ex)
{
Logger.Warn("ConfigurationError executing FtpDownloadJob job.", ex);
}
// Get files
try
{
using (var ftpLibrary = SchedulerContainer.Container.GetInstance <IFtpLibrary>())
{
ftpLibrary.Connect(ftpHost, port, userName, password, sshPrivateKeyPath, sshPrivateKeyPassword);
ftpLibrary.GetFiles(remoteDirectoryPath, localDirectoryPath, fileExtensions, cutOffTimeSpan);
}
}
catch (Exception ex)
{
Logger.Error(string.Format("Error in FtpDownloadJob ({0}):", jobName), ex);
throw new JobExecutionException(ex.Message, ex, false);
}
}
