private void button1_Click(object sender, EventArgs e)
{
if (this.txtUserName.Text.Length < 1)
{
MessageBox.Show("Please Enter User Name");
return;
}
if (this.txtPassword.Text.Length < 1)
{
MessageBox.Show("Please Enter Password");
return;
}
PrincipalContext principalContext = new PrincipalContext(ContextType.Domain, "COS");
principalContext.ValidateCredentials(this.txtUserName.Text, this.txtPassword.Text);
try
{
if (!principalContext.ValidateCredentials(this.txtUserName.Text, this.txtPassword.Text))
{
this.txtPassword.Text = string.Empty;
MessageBox.Show("User Name or Password Not correct");
}
else
{
(new frmMain()).Show();
base.Hide();
}
}
catch (Exception exception)
{
MessageBox.Show(exception.ToString());
}
}
/// <summary>
/// Authenticates a user agains ad
/// </summary>
/// <param name="username">User name</param>
/// <param name="password">password to check</param>
/// <returns>User is ìauthenticated</returns>
public static bool Authenticate(string username, string password)
{
var domain = ConfigurationManager.AppSettings["adDomain"];
using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, domain))
{
return pc.ValidateCredentials(domain + "\\" + username, password) || pc.ValidateCredentials(username, password);
}
}
protected void Unnamed1_Authenticate(object sender, AuthenticateEventArgs e)
{
bool valid = false;
using (var context = new PrincipalContext(ContextType.Domain))
{
var login = sender as System.Web.UI.WebControls.Login;
if (login != null)
{
valid = context.ValidateCredentials(login.UserName, login.Password);
if (valid)
{
var dal = new UsersDal();
var loginWithDomain = AuthProvider.LoginWithDomain(login.UserName);
if (!dal.IsUserExists(AuthProvider.LoginWithDomain(login.UserName)))
{
Session["CurrentUserId"] = dal.RegisterNewUser(loginWithDomain,
AuthProvider.GetUserFullNameByDomainIdentity(login.UserName));
Login1.DestinationPageUrl = "Profile.aspx";
//e.Authenticated = false;
//return;
}
else
{
Session["CurrentUserId"] = (new UsersDal()).GetUserGUIDByLogin(loginWithDomain);
}
Session["CurrentUser"] = loginWithDomain;
dal.UsersStatisticsUpdateLoginCount(AuthProvider.UserKey(Session));
}
}
}
e.Authenticated = valid;
}
public bool validateUser(string username, string password)
{
string UN = username;
string PW = password;
bool state;
bool inGrp = false;
PrincipalContext Context = new PrincipalContext(ContextType.Domain, "wallworkinc.com");
GroupPrincipal group = GroupPrincipal.FindByIdentity(Context, "Help Desk Admins");
state = Context.ValidateCredentials(UN, PW);
if (state != false)
{
foreach (Principal principal in group.Members)
{
string name = principal.SamAccountName;
if (name == UN)
{
inGrp = true;
}
}
}
else
{
inGrp = false;
}
return inGrp;
}
private static bool AuthWindows(string password)
{
var authenticated = false;
var envName = Tools.GetUsernameAsService();
var username = Environment.UserDomainName + "\\" + envName;
//this will fix most domain logins, try first
using (var context = new PrincipalContext(ContextType.Machine))
{
authenticated = context.ValidateCredentials(username, password);
}
//lets try a controller
if (!authenticated)
{
try
{
var domainContext = new DirectoryContext(DirectoryContextType.Domain, Environment.UserDomainName,
username, password);
var domain = Domain.GetDomain(domainContext);
var controller = domain.FindDomainController();
//controller logged in if we didn't throw.
authenticated = true;
}
catch (Exception)
{
authenticated = false;
}
}
return authenticated;
}
public IEnumerable<IPrincipalDetails> GetMembers(string domainName, string username, string password, string groupName)
{
List<PrincipalDetails> results = new List<PrincipalDetails>();
using (PrincipalContext context = new PrincipalContext(ContextType.Domain, domainName, username, password))
{
if (!string.IsNullOrEmpty(username))
{
bool valid = context.ValidateCredentials(username, password);
if (!valid)
throw new SecurityException(null, "Unable to authenticate with '{0}' using '{1}'", domainName, username);
}
try
{
using (GroupPrincipal group = GroupPrincipal.FindByIdentity(context, IdentityType.SamAccountName, groupName))
{
// FindByIdentity returns null if no matches were found
if (group == null)
throw new InvalidOperationException(string.Format("The group {0} could not be found", groupName));
// Add all of the members of this group, and any sub-group to the list of members.
AddGroupMembers(group, results);
}
}
catch (Exception ex)
{
throw new SecurityException(ex, "Unable to query Active Directory.");
}
}
return results;
}
public EntityResponse<User> Login(LoginRequest credentials)
{
var response = new EntityResponse<User> {EntityType = typeof (User).ToString()};
// set up domain context
var ctx = new PrincipalContext(ContextType.Domain);
if (ctx.ValidateCredentials(credentials.UserName, credentials.Password))
{
var user = UserPrincipal.FindByIdentity(ctx, credentials.UserName);
if (user != null)
{
var u = new User
{
Email = user.EmailAddress,
DisplayName = user.DisplayName,
UserName = credentials.UserName
};
response.ResponseCode = ResponseCode.Success;
response.Message = ResponseMessage.Success;
response.Data = u;
}
else
{
SetResponseError(ref response);
}
}
else
SetResponseError(ref response);
return response;
}
public DirectoryEntry Validate(string username, string password)
{
var config = Config.Get<Settings>();
using (var context = new PrincipalContext(ContextType.Domain, config.Domain))
{
bool isValid;
try
{
isValid = context.ValidateCredentials(username, password, ContextOptions.Negotiate);
}
catch (Exception ex)
{
Log.Error("Error authenticating user", ex, this.GetType());
return null;
}
if (!isValid)
return null;
var identity = UserPrincipal.FindByIdentity(context, IdentityType.SamAccountName, username);
return new DirectoryEntry
{
Username = identity.SamAccountName,
Email = identity.EmailAddress.TrimToNull(),
FirstName = identity.GivenName,
LastName = identity.Surname
};
}
}
public string Login(string password, WebSocket clientSocket)
{
var code = 3;
if (string.IsNullOrEmpty(password))
{
code = INVALID_PASSWORD;
}
using (var context = new PrincipalContext(ContextType.Machine))
{
code = context.ValidateCredentials(GetUsername(), password) ? 2 : 3;
}
var authenticated = code == AUTHENTICATED;
foreach (var client in TaskManagerServer.AllClients.Where(client => client.Value.Client == clientSocket))
{
if (code == INVALID_PASSWORD)
{
client.Value.Authenticated = false;
}
else if (code == AUTHENTICATED)
{
client.Value.Authenticated = true;
}
}
var authenticationData = new JavaScriptSerializer().Serialize(new
{
endpoint = "authentication",
results = new
{
authenticated,
message = authenticated ? "Login was successfull" : "Login was unsuccessful"
}
});
return authenticationData;
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
protected void ADValidate(AuthenticateEventArgs e)
{
var domainForValidation = ConfigurationManager.AppSettings["IsHammerTime"] == "True"
? "BOMP" : ConfigurationManager.AppSettings["DomainForValidation"];
using (var pc = new PrincipalContext(ContextType.Domain, domainForValidation))
{
//validate the credentials
try
{
var isValid = pc.ValidateCredentials(LoginUser.UserName, LoginUser.Password);
if (!isValid) return;
Session.Add("credential",LoginUser.Password);
e.Authenticated = true;
var usuario = GetCredentialFromDb();
if (usuario != null)
CreateEncryptedTicket(e, usuario.NombreCompleto);
else
{
LoginUser.FailureText = "El usuario no tiene permisos para acceder a la aplicación.";
e.Authenticated = false;
}
}
catch (Exception exception)
{
LoginUser.FailureText = exception.Message;
e.Authenticated = false;
}
}
}
protected override bool _Validate()
{
using (var adContext = new PrincipalContext (ContextType.Domain, "ad.okstate.edu"))
{
return adContext.ValidateCredentials (user, pass);
}
}
private static bool WindowsAuthenticate(string usuario, string senha)
{
using (var context = new PrincipalContext(ContextType.Machine, "nomedasuamaquina"))
{
return context.ValidateCredentials(usuario, senha);
}
}
private void ProcessOk()
{
try
{
PrincipalContext pcontext = new PrincipalContext(this.contextType, this.domain);
using (pcontext)
{
if (pcontext.ValidateCredentials(this.user, this.textBoxPassword.Text, this.contextOptions) == false)
{
this.labelPassword.ForeColor = System.Drawing.Color.DarkRed;
this.textBoxPassword.BackColor = System.Drawing.Color.Coral;
this.pictureBoxLock.Visible = true;
this.textBoxPassword.Select();
}
else
{
this.password = this.textBoxPassword.Text;
this.labelPassword.ForeColor = System.Drawing.Color.DarkGreen;
this.textBoxPassword.BackColor = System.Drawing.Color.WhiteSmoke;
this.pictureBoxLock.Visible = false;
this.pictureBoxOpenLock.Visible = true;
this.Refresh();
System.Threading.Thread.Sleep(400);
this.Close();
}
}
}
catch (Exception ex)
{
this.exception = ex;
this.Close();
}
}
/// <summary>
/// Authenticates with Active Directory and returns a populated userContext object if authentication is successful
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <returns></returns>
public static userContext authenticateUser(string userName, string password)
{
try
{
userContext uContext = new userContext();
bool authenticated = false;
PrincipalContext domainContext = new PrincipalContext(ContextType.Domain, Properties.Settings.Default.domain, Properties.Settings.Default.domainLDAPbase);
authenticated = domainContext.ValidateCredentials(userName, password, ContextOptions.Negotiate);
if (authenticated)
{
uContext.loggedOn = true;
uContext.SAMAccount = userContext.getUserAccount(userName);
uContext.currentUserAuthorizationGroups = userContext.getGroups(userName);
}
else
{
uContext.loggedOn = false;
}
return uContext;
}
catch (System.DirectoryServices.DirectoryServicesCOMException ex)
{
throw ex;
}
}
public bool Login(String userName, String password)
{
PrincipalContext pc = new PrincipalContext(ContextType.Domain, this.domainName);
bool isValid = false;
isValid = pc.ValidateCredentials(userName, password);
return isValid;
}
public bool Validate(string userName, string password, out ClaimsIdentity oAuthIdentity, out ClaimsIdentity cookiesIdentity)
{
using (var ctx = new PrincipalContext(ContextType.Domain, DomainName))
{
bool isValid = ctx.ValidateCredentials(userName, password);
if (isValid)
{
oAuthIdentity = new ClaimsIdentity(Startup.OAuthBearerOptions.AuthenticationType);
cookiesIdentity = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationType);
var groups=GetUserGroups(userName);
oAuthIdentity.AddClaim(new Claim(ClaimTypes.Name, userName));
cookiesIdentity.AddClaim(new Claim(ClaimTypes.Name, userName));
if (groups.Contains("BD"))
{
oAuthIdentity.AddClaim(new Claim(ClaimTypes.Role, "BD"));
cookiesIdentity.AddClaim(new Claim(ClaimTypes.Role, "BD"));
}
else
{
oAuthIdentity.AddClaim(new Claim(ClaimTypes.Role, string.Join(",", groups)));
cookiesIdentity.AddClaim(new Claim(ClaimTypes.Role, string.Join(",", groups)));
}
}
else
{
oAuthIdentity = null;
cookiesIdentity = null;
}
return isValid;
}
}
public IHttpActionResult Authenticate(AuthenticationRequest authRequest)
{
bool valid = false;
using (var context = new PrincipalContext(ContextType.Machine))
{
if (Principal.FindByIdentity(context, authRequest.Username) != null)
{
valid = context.ValidateCredentials(authRequest.Username, authRequest.Password);
}
}
if (valid)
{
OpaqueSecurityToken token = new OpaqueSecurityToken();
token.SecurePayload[OpaqueSecurityToken.KnownPayloadKeys.USERNAME] = authRequest.Username;
token.SecurePayload[OpaqueSecurityToken.KnownPayloadKeys.TTL_SEC] = (60 * 60).ToString(); // 1 hour
return Ok(new AuthenticationResponse()
{
AuthToken = token.SerializeToString(),
AuthType = AuthMessageHandler.AuthenticationType,
});
}
//throw new HttpResponseException(HttpStatusCode.Unauthorized);
return Content((HttpStatusCode)422, new AuthenticationResponse()
{
ErrorMessage = "Invalid username or password",
});
}
public StringBuilder Execute(Dictionary<string, StringBuilder> values, IWorkspace theWorkspace)
{
string domain = null;
string username = null;
string password = null;
StringBuilder tmp;
values.TryGetValue("Domain", out tmp);
if(tmp != null)
{
domain = tmp.ToString();
}
values.TryGetValue("Username", out tmp);
if(tmp != null)
{
username = tmp.ToString();
}
values.TryGetValue("Password", out tmp);
if(tmp != null)
{
password = tmp.ToString();
}
if(string.IsNullOrEmpty(domain) || string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
{
throw new InvalidDataContractException("Domain or Username or Password is missing");
}
var result = new ExecuteMessage { HasError = false };
try
{
if(domain.Equals("."))
{
domain = Environment.UserDomainName;
}
bool isValid;
using(var context = new PrincipalContext(ContextType.Domain, domain))
{
isValid = context.ValidateCredentials(username, password);
context.Dispose();
}
result.SetMessage(isValid ? "<result>Connection successful!</result>" : "<result>Connection failed. Ensure your username and password are valid</result>");
}
catch
{
result.SetMessage("<result>Connection failed. Ensure your username and password are valid</result>");
}
Dev2JsonSerializer serializer = new Dev2JsonSerializer();
return serializer.SerializeToBuilder(result);
}
public bool ValidateUser(string username, string password)
{
using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, "YOURDOMAIN"))
{
// validate the credentials
return pc.ValidateCredentials(username, password);
}
}
public bool Login(string password)
{
using (PrincipalContext pc = new PrincipalContext(ContextType.Machine))
{
_isValid = pc.ValidateCredentials(Environment.UserName, password);
}
return _isValid;
}
public bool Validate(string login, string pass)
{
using (var context = new System.DirectoryServices.AccountManagement.PrincipalContext(ContextType.Domain, DOMAIN, null, null))
{
//Username and password for authentication.
return(context.ValidateCredentials(login, pass));
}
}
public bool ValidateCredentials(string domain, string user, string pass)
{
using (PrincipalContext context = new PrincipalContext(ContextType.Domain, domain))
{
// validate the credentials
return context.ValidateCredentials(user, pass);
}
}
public bool Authenticate(string usuario, string password)
{
//using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, LDAP_DOMAIN, LDAP_USER, LDAP_PASSWORD))
using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, LDAP_DOMAIN))
{
return pc.ValidateCredentials(usuario, password);
}
}
public bool Authenticate(string username, string password)
{
bool isvalid = false;
using(var pc = new PrincipalContext(ContextType.Domain, "pts18"))
{
isvalid = pc.ValidateCredentials(username, password);
}
return isvalid;
}
public bool ValidateLogin(string userName, string password, string domainName = "")
{
bool valid;
using (var context = new PrincipalContext(ContextType.Domain))
{
valid = context.ValidateCredentials(userName, password);
}
return valid;
}
public static bool authenticateOnLocalMachiche(string username, string password)
{
bool valid = false;
using (PrincipalContext context = new PrincipalContext(ContextType.Machine))
{
valid = context.ValidateCredentials( username, password );
}
return valid;
}
public bool Validate(string login, string pass)
{
using (var context = new System.DirectoryServices.AccountManagement.PrincipalContext(ContextType.Domain, DOMAIN, null, null))
{
//Username and password for authentication.
return context.ValidateCredentials(login, pass);
}
}
public static bool VerifyDomainUserAccount(string domain, string username, string password)
{
Logger.Instance.Debug("Verify domain account, domain:{0}, user:{1}", domain, username);
using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, domain))
{
// validate the credentials
return pc.ValidateCredentials(username, password, ContextOptions.Negotiate);
}
}
public ValidationResult ValidateUser(string username, string password)
{
ValidationResult result = ValidationResult.Failure;
if (String.IsNullOrEmpty(username)) throw new ArgumentException("Value cannot be null or empty", "userName");
if (String.IsNullOrEmpty(password)) throw new ArgumentException("Value cannot be null or empty", "password");
try
{
string domain = GetDomainFromUsername(username);
if (String.IsNullOrEmpty(domain))
{
domain = Configuration.ActiveDirectorySettings.DefaultDomain;
}
using (PrincipalContext principalContext = new PrincipalContext(ContextType.Domain, domain))
{
if (principalContext.ValidateCredentials(username, password))
{
using (UserPrincipal user = UserPrincipal.FindByIdentity(principalContext, username))
{
using (GroupPrincipal group = GroupPrincipal.FindByIdentity(principalContext, Configuration.ActiveDirectorySettings.MemberGroupName))
{
if (group == null)
result = ValidationResult.Failure;
if (user != null)
{
if (!group.GetMembers(true).Contains(user))
{
result = ValidationResult.NotAuthorized;
}
else
{
ADBackend.Instance.Users.AddOrUpdate(new UserModel
{
Name = user.UserPrincipalName,
GivenName = user.GivenName ?? String.Empty,
Surname = user.Surname ?? String.Empty,
Email = user.EmailAddress ?? String.Empty,
});
result = ValidationResult.Success;
}
}
}
}
}
}
}
catch
{
result = ValidationResult.Failure;
}
return result;
}
public static bool VerifyMachineUserAccount(string machineName, string username, string password)
{
Logger.Instance.Debug("Verify machine account, domain:{0}, user:{1}", machineName, username);
using (PrincipalContext pc = new PrincipalContext(ContextType.Machine, machineName))
{
// validate the credentials
return pc.ValidateCredentials(username, password);
}
}
public static Boolean checkPw(String username, String password)
{
if (password == String.Empty)
return false;
using (PrincipalContext pc = new PrincipalContext(ContextType.Domain, DOMAIN))
{
Boolean isValid = pc.ValidateCredentials(username, password);
return isValid;
}
}
//private string sDomain = ConfigurationManager.AppSettings["sDomain"];
//private string sDefaultOU = ConfigurationManager.AppSettings["sDefaultOU"];
//private string sDefaultRootOU = ConfigurationManager.AppSettings["sDefaultRootOU"];
//private string sServiceUser = ConfigurationManager.AppSettings["sServiceUser"];
//private string sServicePassword = ConfigurationManager.AppSettings["sServicePassword"];
//private string sDomain = "test.com";
//private string sDefaultOU = "OU=Test Users,OU=Test,DC=test,DC=com";
//private string sDefaultRootOU = "DC=test,DC=com";
//private string sServiceUser = @"ServiceUser";
//private string sServicePassword = "******";
#endregion
#region Methods
/// <summary>
/// Validates the username and password of a given user
/// </summary>
/// <param name="sUserName">The username to validate</param>
/// <param name="sPassword">The password of the username to validate</param>
/// <returns>Returns True of user is valid</returns>
private bool ValidateCredentials(string sUserName, string sPassword)
{
PrincipalContext oPrincipalContext = GetPrincipalContext();
return(oPrincipalContext.ValidateCredentials(sUserName, sPassword));
}
