void LoginClick(object sender, RoutedEventArgs e)
{
string p = this.password.Password;
if (string.IsNullOrWhiteSpace(p))
{
return;
}
if (CryptHelper.Encrypt(p) == "312351333348315291330321303363306315330300303342")
{
MainWindow mainWindow = new MainWindow();
App.Current.MainWindow = mainWindow;
this.Close();
mainWindow.Show();
}
}
private string CreateAuthorazitionCode(RequestParam param)
{
var db = redis.GetDatabase();
string code = db.StringGet(param.client_id);
if (string.IsNullOrEmpty(code))
{
//生成授权码
code = CryptHelper.EncryptByMD5_Base64(DateTime.Now.Ticks.ToString());
//保存授权码
db.StringSet(param.client_id, code, TimeSpan.FromSeconds(600));
//授权码是否不使用，0表示没有使用，1表示使用过
db.StringSet(code, 0, TimeSpan.FromSeconds(600));
}
return(code);
}
static void Main(string[] args)
{
string salt = null;
var password = "******";
var hashPassword = CryptHelper.HashPassword(password, out salt);
Console.WriteLine("Password => {0}", password);
Console.WriteLine("HashPassword => {0}", hashPassword);
Console.WriteLine("Salt => {0}", salt);
var matchs = CryptHelper.VerifyPassword(password, hashPassword, salt);
Console.WriteLine("Matchs: {0}", matchs);
Console.ReadLine();
}
public AbstractModel ListOfWorkoutsName(LoginModel loginModel)
{
LoginModel decryptedModel = new LoginModel();
decryptedModel.userName = CryptHelper.Decrypt(loginModel.userName);
user user = findUser(decryptedModel.userName);
//user user = findUser(loginModel.userName);
if (user == null)
{
return(ResultHelper.boolResult(false, "User not exist !!!"));
}
//return ResultHelper.workoutsRessult(loginModel.userName);
return(ResultHelper.workoutsRessult(decryptedModel.userName));
//return ResultHelper.boolResult(true,"gfgf");
}
/// <summary>
/// 密码加密
/// </summary>
public void EncryptPassword()
{
if (Password.IsNullOrEmpty())
{
return;
}
var result = CryptHelper.EncryptMD5(Password);
if (this.Factor.HasValue)
{
result = CryptHelper.EncryptMD5(result + this.Factor.Value);
}
result = CryptHelper.EncryptSha256(result);
Password = result;
}
public AbstractModel DeleteTask(TaskModel taskModel)
{
TaskModel decryptedModel = new TaskModel();
decryptedModel.workoutName = CryptHelper.Decrypt(taskModel.workoutName);
decryptedModel.taskName = CryptHelper.Decrypt(taskModel.taskName);
//try to delete task
bool didDeleteTask = deleteTask(decryptedModel.workoutName, decryptedModel.taskName);
if (didDeleteTask)
{
return(ResultHelper.boolResult(true, "Deleting Task success"));
}
return(ResultHelper.boolResult(false, "Deleting Task failure"));
}
public AbstractModel DeleteWorkout(WorkoutModel workoutModel)
{
WorkoutModel decryptedModel = new WorkoutModel();
decryptedModel.userName = CryptHelper.Decrypt(workoutModel.userName);
decryptedModel.workoutName = CryptHelper.Decrypt(workoutModel.workoutName);
//try to delete workout
bool didDeleteWorkout = deleteWorkout(decryptedModel.userName, decryptedModel.workoutName);
if (didDeleteWorkout)
{
return(ResultHelper.boolResult(true, "Deleting Workout success"));
}
return(ResultHelper.boolResult(false, "Deleting Workout failure"));
}
public bool CheckPassword(string pwd)
{
if (pwd.IsNullOrEmpty())
{
return(false);
}
var result = CryptHelper.EncryptMD5(pwd);
if (this.Factor.HasValue)
{
result = CryptHelper.EncryptMD5(result + this.Factor.Value);
}
result = CryptHelper.EncryptSha256(result);
return(result.EqualOrdinalIgnoreCase(this.Password));
}
public String PasswordCheck()
{
List <User> users = _context.Users.ToList();
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("Checking users:\n");
foreach (User user in users)
{
Boolean check = CryptHelper.CheckPassword("P@ss1234", user.Password);
stringBuilder.Append("User " + user.Username + " password: "******"same" : "not same") + "\n");
}
stringBuilder.Append("Finished");
return(stringBuilder.ToString());
}
public void GivenAnInvalidUnencryptedString_WhenEncryptStringIsEnvoked_ThenReturnsAnDifferentEncryptedString()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockSettings = new Mock <ConfigurationHelper>(mockConfiguration.Object);
mockSettings.Setup(s => s.GetCryptoKey()).Returns(_cryptoKey);
mockSettings.Setup(s => s.GetCryptoVector()).Returns(_cryptoVector);
var sut = new CryptHelper(mockSettings.Object);
// Act
var result = sut.EncryptString(_otherPlainTextDecrypted);
// Assert
Assert.NotEqual(_plainTextEncrypted, result);
}
public void GivenAnUnencryptedString_WhenEncryptStringIsEnvoked_ThenReturnsAnCorrectlyEncryptedString()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockSettings = new Mock <ConfigurationHelper>(mockConfiguration.Object);
mockSettings.Setup(s => s.GetCryptoKey()).Returns(_cryptoKey);
mockSettings.Setup(s => s.GetCryptoVector()).Returns(_cryptoVector);
var sut = new CryptHelper(mockSettings.Object);
// Act
var result = sut.EncryptString(_plainTextDecrypted);
// Assert
Assert.Equal(0, string.CompareOrdinal(_plainTextEncrypted, result));
}
public void UpdateManufactureSettings(string id)
{
if (!string.IsNullOrEmpty(this.Parent.Manufacturer) && string.Compare(this.Parent.Manufacturer, id, true) != 0)
{
throw new Exception(string.Format("Manufacturer type does not match. Manufacturer is {0} and it should be {1}.", id, this.Parent.Manufacturer));
}
GXManufacturer manufacturer = this.Parent.Manufacturers.FindByIdentification(id);
if (manufacturer == null)
{
throw new Exception("Unknown manufacturer " + id);
}
this.Parent.Manufacturer = manufacturer.Identification;
m_Cosem.Authentication = this.Parent.Authentication;
m_Cosem.InterfaceType = InterfaceType.General;
if (!string.IsNullOrEmpty(this.Parent.Password))
{
m_Cosem.Password = CryptHelper.Decrypt(this.Parent.Password, Password.Key);
}
m_Cosem.UseLogicalNameReferencing = this.Parent.UseLogicalNameReferencing;
//If network media is used check is manufacturer supporting IEC 62056-47
if (!Parent.UseRemoteSerial && this.Media is GXNet && manufacturer.UseIEC47)
{
m_Cosem.InterfaceType = InterfaceType.Net;
m_Cosem.ClientID = Convert.ToUInt16(Parent.ClientID);
m_Cosem.ServerID = Convert.ToUInt16((Parent.LogicalAddress << 9) | Convert.ToUInt16(Parent.PhysicalAddress));
}
else
{
if (Parent.HDLCAddressing == HDLCAddressType.Custom)
{
m_Cosem.ClientID = Parent.ClientID;
}
else
{
m_Cosem.ClientID = (byte)(Convert.ToByte(Parent.ClientID) << 1 | 0x1);
}
string formula = null;
GXServerAddress server = manufacturer.GetServer(Parent.HDLCAddressing);
if (server != null)
{
formula = server.Formula;
}
m_Cosem.ServerID = GXManufacturer.CountServerAddress(Parent.HDLCAddressing, formula, Parent.PhysicalAddress, Parent.LogicalAddress);
}
}
public AbstractModel DeleteWorkoutFromFavoritesList(FavoritesModel favoritesModel)
{
FavoritesModel decryptedModel = new FavoritesModel();
decryptedModel.masterUserName = CryptHelper.Decrypt(favoritesModel.masterUserName);
decryptedModel.userName = CryptHelper.Decrypt(favoritesModel.userName);
decryptedModel.workoutName = CryptHelper.Decrypt(favoritesModel.workoutName);
//try to delete workout
bool didDeleteWorkout = deleteWorkoutFromList(decryptedModel.masterUserName, decryptedModel.userName, decryptedModel.workoutName);
if (didDeleteWorkout)
{
return(ResultHelper.boolResult(true, "Deleting Workout success"));
}
return(ResultHelper.boolResult(false, "Deleting Workout failure"));
}
// GET: Register
public ActionResult Index(string fullName = "", string email = "", string password = "", string retypePassword = "", string photo = "")
{
if (Request.HttpMethod == "POST")
{
if (string.IsNullOrWhiteSpace(fullName))
{
fullName = Convert.ToString(Session["fullName"]);
}
if (string.IsNullOrWhiteSpace(email))
{
email = Convert.ToString(Session["email"]);
}
Session["fullName"] = fullName;
Session["email"] = email;
var emailExist = AccountService.EmailExist(email);
if (emailExist != "")
{
ModelState.AddModelError("email", "Email đã tồn tại");
return(View());
}
if (password != retypePassword)
{
ModelState.AddModelError("retypePassword", "Nhập lại mật khẩu không đúng");
return(View());
}
var names = fullName.Split(' ');
var firstName = "";
var lastName = "";
if (names.Length == 1)
{
firstName = names[0];
}
else
{
firstName = names[1];
lastName = names[0];
}
AccountService.Register(lastName, firstName, email, CryptHelper.Md5(password), photo);
/* return Json(account, JsonRequestBehavior.AllowGet);*/
return(RedirectToAction("Login", "Account"));
}
else
{
return(View());
}
}
public void UpdateCompanyPartnerCredentials(CompanyPartner companyPartner)
{
try
{
StandartPersistence standartPersistence =
new StandartPersistence(this.Connection);
companyPartner.Password = CryptHelper.Encrypt(companyPartner.Password);
standartPersistence.Execute(CommandType.Text,
"UPDATE CompanyPartner SET Email = @Email, [Password] = @Password WHERE Email = @Email AND [Password] = @Password",
new { companyPartner.Email, companyPartner.Password });
}
catch (SqlException e)
{
throw e;
}
}
public AbstractModel TaskByName(TaskModel taskModel)
{
TaskModel decryptedModel = new TaskModel();
decryptedModel.taskName = CryptHelper.Decrypt(taskModel.taskName);
// get task by name
task _task = findTask(decryptedModel.taskName);
//task _task = findTask(taskModel.taskName);
if (_task == null)
{
return(ResultHelper.boolResult(false, "Task not exist !!!"));
}
//return ResultHelper.taskByNameResult(taskModel.taskName);
return(ResultHelper.taskByNameResult(decryptedModel.taskName));
}
public AbstractModel ListOfTaskName(WorkoutModel workoutModel)
{
WorkoutModel decryptedModel = new WorkoutModel();
decryptedModel.userName = CryptHelper.Decrypt(workoutModel.userName);
decryptedModel.workoutName = CryptHelper.Decrypt(workoutModel.workoutName);
//get workout by name
workout _workout = findWorkout(decryptedModel.workoutName);
//workout _workout = findWorkout(workoutModel.workoutName);
if (_workout == null)
{
return(ResultHelper.boolResult(false, "Workout not exist !!!"));
}
//return ResultHelper.tasksRrssult(workoutModel.workoutName);
return(ResultHelper.tasksRrssult(decryptedModel.workoutName));
}
public void UpdateClientCredentials(Model.Profile.Client.Entity.B2C.Client client)
{
try
{
StandartPersistence standartPersistence =
new StandartPersistence(this.Connection);
client.Password = CryptHelper.Encrypt(client.Password);
standartPersistence.Execute(CommandType.Text,
"UPDATE Client SET Email = @Email, [Password] = @Password WHERE Email = @Email AND [Password] = @Password",
new { client.Email, client.Password });
}
catch (SqlException e)
{
throw e;
}
}
// GET: ChangePassword
/// <summary>
///
/// </summary>
/// <returns></returns>
public ActionResult Index(string accountId = "", string oldPassword = "", string newPassword = "")
{
if (Request.HttpMethod == "POST")
{
bool account = AccountService.ChangePassword(accountId, CryptHelper.Md5(oldPassword), CryptHelper.Md5(newPassword));
if (account == false)
{
ModelState.AddModelError("", "Mật khẩu không đúng!");
return(View());
}
// Quay về trang chủ
return(RedirectToAction("Index", "Home"));
}
else
{
return(View());
}
}
public string GetEncryptedString(string name)
{
byte[] encrypted = GetByteArray(name, null);
if (encrypted == null)
{
return(null);
}
try
{
return(CryptHelper.Decrypt(encrypted));
}
catch (Exception e)
{
Trace.Fail("Failure during decrypt: " + e);
return(null);
}
}
private static (HttpStatusCode, Stream) ProcessRequest(Stream inputStream, string rawRequestInfo)
{
try
{
var request = GetRequest(rawRequestInfo);
if (string.IsNullOrEmpty(request?.UserInfo?.UserName) || string.IsNullOrEmpty(request.ApiMethod))
{
Console.WriteLine("Bad request");
return(HttpStatusCode.BadRequest, Stream.Null);
}
if (!Auth.Instance.Value.IsAuthorized(request.UserInfo))
{
Console.WriteLine($"Unauthorized user \"{request.UserInfo.UserName}\"");
return(HttpStatusCode.Unauthorized, Stream.Null);
}
var apiAction = request.ApiMethod;
var isMethodImplemented = ApiControllersInitializer.Instance.
RequestToControllersDictionary.TryGetValue(apiAction.ToLowerInvariant(), out var processor);
if (!isMethodImplemented)
{
Console.WriteLine($"Unsupported method {apiAction}");
return(HttpStatusCode.NotImplemented, Stream.Null);
}
if (!Auth.Instance.Value.HasUserPermission(request.UserInfo, apiAction))
{
Console.WriteLine($"User \"{request.UserInfo.UserName}\" not permitted to \"{apiAction}\"");
return(HttpStatusCode.Forbidden, Stream.Null);
}
Console.WriteLine($"User: \"{request.UserInfo.UserName}\"{Environment.NewLine}Method: \"{apiAction}\"");
var decryptedContent = CryptHelper.Decrypt(CryptHelper.MasterPass, inputStream).Result;
return(processor.ProcessRequest(request.ContentInfo, decryptedContent));
}
catch (Exception e)
{
LogManager.WriteError(e, "Error while processing request");
return(HttpStatusCode.InternalServerError, Stream.Null);
}
}
private static async Task ProcessConnectionAsync(HttpListenerContext context)
{
var contextRequest = context.Request;
var contextResponse = context.Response;
var response = Stream.Null;
Console.WriteLine($"Request #{++_requestCount}");
Console.WriteLine($"Client IP: {contextRequest.RemoteEndPoint}");
Console.WriteLine($"Client UserAgent: {contextRequest.UserAgent}");
var postHttpMethod = HttpMethod.Post.Method;
if (!contextRequest.HttpMethod.Equals(postHttpMethod))
{
Console.WriteLine($"Http method wasn't {postHttpMethod}");
}
else
{
if (!contextRequest.Headers.AllKeys.Contains(CommonConstants.RequestInfoHeaderName))
{
Console.WriteLine($"Headers hasn't {CommonConstants.RequestInfoHeaderName}");
}
else
{
var rawRequestInfo = contextRequest.Headers[CommonConstants.RequestInfoHeaderName];
HttpStatusCode code;
(code, response) = ProcessRequest(contextRequest.InputStream, rawRequestInfo);
contextResponse.StatusCode = (int)code;
}
}
contextResponse.ContentType = "application/json";
contextResponse.ContentEncoding = CommonConstants.StandardEncoding;
await using var encryptedData = await CryptHelper.Encrypt(CryptHelper.MasterPass, response);
contextResponse.ContentLength64 = encryptedData.Length;
await encryptedData.CopyToAsync(contextResponse.OutputStream);
contextResponse.Close();
Console.WriteLine();
}
static List <UserProfile> GetUserProfiles()
{
string salt = CryptHelper.CreateSalt(256);
var profiles = new List <UserProfile>
{
new UserProfile
{
id = 1,
Username = "******",
Password = CryptHelper.CreatePasswordHash("password", salt),
Salt = salt,
PersonId = 1, // David King
CanBeDeleted = false,
SecurityQuestion = "What is your cat's name?",
SecurityAnswer = CryptHelper.CreatePasswordHash("Precious", salt)
},
new UserProfile
{
id = 2,
Username = "******",
Password = CryptHelper.CreatePasswordHash("password", salt),
Salt = salt,
PersonId = 2, // Bob Roggio
CanBeDeleted = false,
SecurityQuestion = "What is your cat's name?",
SecurityAnswer = CryptHelper.CreatePasswordHash("Gabbie", salt)
},
new UserProfile
{
id = 3,
Username = "******",
Password = CryptHelper.CreatePasswordHash("password", salt),
Salt = salt,
PersonId = 2, // Carly Pellegrini
CanBeDeleted = false,
SecurityQuestion = "What is your mother's maiden name?",
SecurityAnswer = CryptHelper.CreatePasswordHash("Ray", salt)
}
};
return(profiles);
}
public ActionResult Test()
{
var unionid = "ok0Ues51PAh5nKaz53slvacjdD5E";
var key = "lkwx7877787952213dddddeddss";
var money = "0.3";
var time = "2019年5月9日";
var dict = new Dictionary <string, string>
{
{ "unionid", unionid },
{ "money", money },
{ "time", time },
{ "sign", CryptHelper.MD5Hash(money + "_" + unionid + "_" + key).ToLower() },
};
// var ss = CryptHelper.MD5(unionid + key, 32).ToLower();
// var result = WebUtils.DoPost("https://apiqa.lkgame.com/superlottery/sendgood?integralaward=1&integraltype=1&cashbalanceaward=1", dict);
var result = WebUtils.DoPost("http://m.lkgame.com/WechatSmallGameRedPackage/DoRed", dict);
return(View());
}
public DynamicService()
{
InitializeComponent();
try {
var doc = new XmlDocument();
doc.Load(string.Format("{0}DynamicDNS.exe.config", AppDomain.CurrentDomain.BaseDirectory));
var appSettings = doc.GetElementsByTagName("add").OfType <XmlNode>().ToDictionary(t => t.Attributes["key"].Value.ToLower(), (t) => t.Attributes["value"].Value);
if (appSettings.ContainsKey("email"))
{
email = CryptHelper.AESDecrypt(appSettings["email"]);
}
if (appSettings.ContainsKey("password"))
{
password = CryptHelper.AESDecrypt(appSettings["password"]);
}
if (appSettings.ContainsKey("domain"))
{
domain = CryptHelper.AESDecrypt(appSettings["domain"]);
}
if (appSettings.ContainsKey("subdomain"))
{
subDomain = CryptHelper.AESDecrypt(appSettings["subdomain"]);
}
if (appSettings.ContainsKey("updateinterval"))
{
var _updateInterval = appSettings["updateinterval"];
int.TryParse(_updateInterval, out updateInterval);
updateInterval = Math.Max(updateInterval, 5);
}
}
catch (Exception ex) {
Logger.Write("配置文件不存在或配置不正确：{0}", ex.Message);
}
timer = new Timer();
timer.Elapsed += timer_Elapsed;
}
public dynamic GenerateTokenUser(dynamic request)
{
User user = this.LoginUser(request);
string key1 = (string)request.email;
string key2 = (string)request.password;
DateTime now = CryptHelper.BrazilEast(DateTime.Now);
string key1Encrypted = CryptHelper.ToCrypt(key1);
string key2Encrypted = CryptHelper.ToCrypt(key2);
string nowEncrypted = CryptHelper.ToCrypt(now.ToString());
return(new
{
accessToken = key1Encrypted + ":" + key2Encrypted + ":" + nowEncrypted,
userId = user.Id.ToString(),
email = user.Email
});
}
public async Task <AuthenticateResponse> Register(UserModel userModel)
{
var user = _mapper.Map <User>(userModel);
var aesKey = CryptHelper.GenerateAesKeys();
user.Key = aesKey.Key;
user.Iv = aesKey.Iv;
await _dbRepository.Add(user);
var response = Authenticate(new AuthenticateRequest
{
Username = user.Username,
Password = user.Password
});
return(response);
}
public void Save()
{
try
{
using var f = new FileStream(_filePath, FileMode.OpenOrCreate);
string buffer;
lock (Lock)
{
buffer = JsonSerializer.Serialize(BD);
}
var encryptedFile = CryptHelper.Encrypt(_pass, buffer).Result;
f.Write(encryptedFile);
}
catch (Exception e)
{
LogManager.WriteError(e, "BD saving failed");
}
}
// GET: Account
public ActionResult Login(string loginName = "", string password = "")
{
ViewBag.LoginName = loginName;
if (Request.HttpMethod == "POST")
{
var account = AccountService.Authorize(loginName, CryptHelper.Md5(password));
if (account == null)
{
ModelState.AddModelError("", "Thông tin đăng nhập bị sai");
return(View());
}
System.Web.Security.FormsAuthentication.SetAuthCookie(CookieHelper.AccountToCookieString(account), false);
return(RedirectToAction("Index", "Home"));
}
else
{
return(View());
}
}
//[Fact]
public static void Init(UnitTestInit i)
{
XlfResourcesHSunamo.SaveResouresToRLSunamo();
CryptHelper.ApplyCryptData(CryptHelper.RijndaelBytes.Instance, CryptDataWrapper.rijn);
// First must ApplyCryptData
if (i.cryptData)
{
CryptHelper.ApplyCryptData(CryptHelper.RijndaelBytes.Instance, CryptDataWrapper.rijn);
}
// Then I can connect
if (i.databases.HasValue)
{
DatabasesConnections.SetConnToMSDatabaseLayer(i.databases.Value, null);
}
}
