Example #1
0
        public ActionResult EditUsuario(Guid id)
        {
            if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
            {
                return(RedirectToAction("Index", "Home"));
            }

            ViewBag.Title      = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
            ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
            UsuarioViewModel model = new UsuarioViewModel();

            using (SeguricelEntities db = new SeguricelEntities())
            {
                Encriptador Encrypt = new Encriptador();
                Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);

                Usuario usuario = (from d in db.Usuario
                                   where d.IdUsuario == id
                                   select d).FirstOrDefault();

                string decryptedPassword = Encrypt.Encriptar(usuario.ClaveUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
                if (usuario != null)
                {
                    model.ConfirmPasswordUsuario = decryptedPassword;
                    model.EmailUsuario           = usuario.Email;
                    model.Estado          = usuario.IdEstadoUsuario;
                    model.Id              = usuario.IdUsuario;
                    model.IdTipoUsuario   = usuario.IdTipoUsuario;
                    model.Nombre          = usuario.Nombre;
                    model.PasswordUsuario = decryptedPassword;
                }
            }

            return(View(model));
        }
Example #2
0
        public IActionResult MantenimientoParametros([FromForm] ParametrosCorreoDto objParametrosCorreoDto)
        {
            var jsonResponseDto = new JsonResponseDto();

            try
            {
                objParametrosCorreoDto.Password = Encriptador.Encriptar(objParametrosCorreoDto.Password);
                var message = (objParametrosCorreoDto.IdParametros == null) ? Constante.registroExitoso : Constante.actualizacionExitoso;
                objParametrosCorreoDto.IdParametros = (objParametrosCorreoDto.IdParametros == null) ? "" : objParametrosCorreoDto.IdParametros;
                objParametrosCorreoDto.Password     = (objParametrosCorreoDto.Password == null) ? "" : objParametrosCorreoDto.Password;
                var response = _Empresa.MantenimientoParametrosCorreo(objParametrosCorreoDto);
                if (response >= 1)
                {
                    jsonResponseDto.Type    = Constante.Success.ToLower();
                    jsonResponseDto.IsValid = true;
                    jsonResponseDto.Mensaje = message;
                }
                else
                {
                    // Log.Error(response.Content.ToString());
                    jsonResponseDto.Type    = Constante.Warning.ToLower();
                    jsonResponseDto.IsValid = false;
                    jsonResponseDto.Mensaje = Constante.registroError;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.Message);
                jsonResponseDto.Type    = Constante.Warning.ToLower();
                jsonResponseDto.IsValid = false;
                jsonResponseDto.Mensaje = ex.Message.ToString();
            }
            return(Json(jsonResponseDto));
        }
Example #3
0
        public IActionResult UserLogin([FromForm] UsuarioConsultaDto objUsuarioConsultaDto)
        {
            objUsuarioConsultaDto.Password = Encriptador.Encriptar(objUsuarioConsultaDto.Password);
            if (string.IsNullOrWhiteSpace(objUsuarioConsultaDto.Password))
            {
                ViewBag.Error = "Ingrese Usuario o Contraseña";
                return(View("Index"));
            }
            HttpContext.Session.SetString("Usu", objUsuarioConsultaDto.Usuarios);
            HttpContext.Session.SetString("Pas", objUsuarioConsultaDto.Password);
            try
            {
                objUsuarioConsultaDto = _Usuario.UsuarioLogin(objUsuarioConsultaDto);
                if (string.IsNullOrEmpty(objUsuarioConsultaDto.Correo))
                {
                    ViewBag.Error = "Usuario o Contraseña Incorrecto";
                    UsuarioLoginDto objUsuarioLoginDto = new UsuarioLoginDto();
                    objUsuarioLoginDto.Tipo = "Login";
                    return(View("Index", objUsuarioLoginDto));
                }


                GenerateTicketAuthentication(objUsuarioConsultaDto);
                Log.Information("INICIO");
                HttpContext.Session.SetString("_TipoEmpresa", GetPerfil());
                // HttpContext.Session.SetString("_TipoEmpresa",objUsuarioConsultaDto.TipoEmpresa);
                return(RedirectToAction("Index", "Home"));
            }
            catch (Exception ex)
            {
                Log.Error(ex.Message);
                ViewBag.Error = "Usuario o Contraseña Incorrecto";
                return(View("Index"));
            }
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            //verificamos la sesion si esta activa en dado caso no exista ira al inicio (LOGIN)
            try
            {
                var sesion_c = Session.Count;
                if (sesion_c <= 0)
                {
                    Response.Redirect("Login.aspx", true);
                    return;
                }
            }
            catch { }


            curso_id = Request.QueryString["id"].ToString();
            curso_id = Encriptador.Desencriptar_Md5(curso_id);
            string p      = Session["perfil"].ToString();
            int    perfil = Convert.ToInt32(p);

            if (!(perfil >= 1))
            {
                Response.Redirect("Index.aspx", true);
            }
        }
Example #5
0
        private void btnIniciarSesion_Click(object sender, EventArgs e)
        {
            if (Encriptador.CompararMD5(txtpassword.Text, cmbUsuario.SelectedValue.ToString()))
            {
                Appuser c = (Appuser)cmbUsuario.SelectedItem;

                if (c.userType)
                {
                    RegistroDAO.iniciarSesion(c.username);

                    MessageBox.Show("¡Bienvenido!",
                                    "apphugo", MessageBoxButtons.OK, MessageBoxIcon.Information);

                    frmPrincipal ventana = new frmPrincipal();
                    ventana.Show();
                    this.Hide();
                }
            }
            else
            {
                MessageBox.Show("¡Bienvenido!", "hugoapp",
                                MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
            frmPrincipal aventana = new frmPrincipal();

            aventana.Show();
            this.Hide();
        }
Example #6
0
 public bool AddUsuario(Usuario usuario)
 {
     usuariosDAL        = new UsuariosDALImpl();
     usuario.contrasena = Encriptador.Encrypt(usuario.contrasena, true);
     usuariosDAL.AddUsuario(usuario);
     return(true);
 }
Example #7
0
        public ActionResult Ingresar(string returnUrl)
        {
            try
            {
                const string        mensaje = "El usuario y/o clave son incorrectos";
                string              nombre  = Request.Form["txtUsuario"];
                string              clave   = Request.Form["txtClave"];
                SeguridadRepository repo    = new SeguridadRepository();
                Usuario             usuario = repo.ObtenerUsuario(nombre);

                if (usuario != null && Encriptador.EncriptarMD5(clave) == usuario.Clave)
                {
                    FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(1, usuario.Nombre, DateTime.Now, DateTime.Now.AddDays(1),
                                                                                     true, usuario.Nombre, FormsAuthentication.FormsCookiePath);

                    string encTicket = FormsAuthentication.Encrypt(ticket);
                    Response.Cookies.Add(new HttpCookie(FormsAuthentication.FormsCookieName, encTicket));
                    Session["estado"] = null;
                    return(Redirect(returnUrl));
                }
                else
                {
                    ViewData["mensaje"]   = mensaje;
                    ViewData["returnUrl"] = returnUrl;
                    return(View());
                }
            }
            catch (Exception ex)
            {
                return(View("Mensaje", new HomeView {
                    Mensaje = ex.Message
                }));
            }
        }
Example #8
0
        public bool VerificarPassword()
        {
            Encriptador encriptador = new Encriptador();

            if (encriptador.Encriptar(txtPasswordAnterior.Text) == Usuario.Password)
            {
                txtPasswordAnterior.BackColor = Color.White;
                lblPassword.Text = "Los campos de contraseña no son iguales.";
                if (txtPassword.Text.Trim() == txtPassword2.Text.Trim() && txtPassword.Text.Trim() != "")
                {
                    txtPassword.BackColor  = Color.White;
                    txtPassword2.BackColor = Color.White;
                    lblPassword.Visible    = false;
                    return(true);
                }
                else
                {
                    txtPassword.BackColor  = Color.HotPink;
                    txtPassword2.BackColor = Color.HotPink;
                    lblPassword.Visible    = true;
                    return(false);
                }
            }
            else
            {
                txtPasswordAnterior.BackColor = Color.HotPink;
                lblPassword.Text    = "La contraseña antigua no es correcta.";
                lblPassword.Visible = true;
                return(false);
            }
        }
Example #9
0
        public static Usuario Login(string cpf, string senha)
        {
            SqlCommand cmd = new SqlCommand
            {
                CommandText = "SELECT * FROM usuario where cpf = @cpf and senha = @senha"
            };

            cmd.Parameters.AddWithValue("@cpf", cpf);
            cmd.Parameters.AddWithValue("@senha", Encriptador.Sha256(senha));

            cmd.Connection = ConexaoFactory.GetConexao();
            SqlDataReader reader = cmd.ExecuteReader();

            if (reader.HasRows)
            {
                reader.Read();
                Usuario usuario = new Usuario((int)reader["id"], (string)reader["nome"], (string)reader["cpf"], (string)reader["rg"], (string)reader["senha"], (int)reader["status"], (int)reader["perfil"]);
                reader.Close();
                ConexaoFactory.Desconectar();
                return(usuario);
            }
            else
            {
                ConexaoFactory.Desconectar();
                throw new Exception("Usuário ou senha incorreta");
            }
        }
Example #10
0
        public ActionResult RestaurarClave(string id)
        {
            try
            {
                UsuarioRepository ur    = new UsuarioRepository();
                UsuarioView       uv    = new UsuarioView();
                string            token = Request.Form["token"];
                int     usuarioId       = ur.ObtenerIdPorToken(token);
                Usuario usuario         = ur.Obtener(usuarioId);

                if (usuario != null)
                {
                    string clave           = Request.Form["txtClave"];
                    string claveEncriptada = Encriptador.EncriptarMD5(clave);
                    if (ur.CambiarClave(usuarioId, claveEncriptada))
                    {
                        uv.Mensaje = "Se cambió la clave satisfactoriamente.";
                    }
                    else
                    {
                        uv.Mensaje = "Hubo un problema al cambiar la clave.";
                    }
                }
                else
                {
                    uv.Mensaje = "El token no es válido.";
                }
                return(View("Mensaje", uv));
            }
            catch (Exception ex)
            {
                return(View("Mensaje", ex.Message));
            }
        }
Example #11
0
        private void button1_Click(object sender, EventArgs e)
        {
            bool actualIgual = Encriptador.CompararMD5(textBox1.Text, comboBox1.SelectedValue.ToString());
            bool nuevaIgual  = textBox2.Text.Equals(textBox3.Text);
            bool nuevaValida = textBox2.Text.Length > 0;

            if (actualIgual && nuevaIgual && nuevaValida)
            {
                try
                {
                    AppUserDAO.actualizarContra(comboBox1.Text, Encriptador.CrearMD5(textBox2.Text));

                    MessageBox.Show("¡Contraseña actualizada exitosamente!",
                                    "SourceCode", MessageBoxButtons.OK, MessageBoxIcon.Information);

                    this.Close();
                }
                catch (Exception)
                {
                    MessageBox.Show("¡Contraseña no actualizada! Favor intente mas tarde.",
                                    "SourceCode", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            else
            {
                MessageBox.Show("¡¡Favor verifique que los datos sean correctos!",
                                "SourceCode", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
Example #12
0
        protected void btnAceptar_Click(object sender, EventArgs e)
        {
            Usuario dalUsuario;

            dalUsuario = (Usuario)Session["UsuarioUpdate"];

            /*
             *          dalUsuario.Calle = txtCalle.Text;
             *          dalUsuario.Numero = txtNro.Text;
             *          dalUsuario.Piso = txtPiso.Text;
             *          dalUsuario.Departamento = txtDpto.Text;
             *          dalUsuario.Barrio = txtBarrio.Text;
             *          dalUsuario.CodigoPostal = txtCodPos.Text;
             *          dalUsuario.IdLocalidad = Convert.ToInt32(ddlLocalidad.SelectedValue);
             *          dalUsuario.IdProvincia = Convert.ToInt32(ddlProvincia.SelectedValue);
             */
            dalUsuario.Modificar();
            dalUsuario.RegistrarIngreso();
            if (pwdAnterior.Text != "" && pwdNuevo.Text == pwdNuevo2.Text && Usuario.AutenticarUsuario(txtLoginName.Text, pwdAnterior.Text))
            {
                StringBuilder strSqlUpdate = new StringBuilder(128);
                strSqlUpdate.Append("Update Usuarios ");
                strSqlUpdate.Append(" Set Password = "******" Where LoginName = " + StaticDal.Traduce(txtLoginName.Text));
                try
                {
                    StaticDal.EjecutarComando(strSqlUpdate.ToString());
                }
                catch
                { }
            }
            Salir();
        }
Example #13
0
 public ActionResult CambiarClave(string id)
 {
     try
     {
         UsuarioView uv        = new UsuarioView();
         int         usuarioId = int.Parse(Request.Form["id"]);
         Usuario     usuario   = ObtenerUsuario();
         if (usuario.Id == usuarioId)
         {
             string            clave           = Request.Form["txtClave"];
             string            claveEncriptada = Encriptador.EncriptarMD5(clave);
             UsuarioRepository ur = new UsuarioRepository();
             if (ur.CambiarClave(usuarioId, claveEncriptada))
             {
                 uv.Mensaje = "Se cambió la clave satisfactoriamente.";
             }
             else
             {
                 uv.Mensaje = "Hubo un problema al cambiar la clave.";
             }
         }
         else
         {
             uv.Mensaje = "Se ha alterado la página de origen.";
         }
         return(View("Mensaje", uv));
     }
     catch (Exception ex)
     {
         return(View("Mensaje", ex.Message));
     }
 }
Example #14
0
        private void btnChangePass_Click(object sender, EventArgs e)
        {
            bool actualIgual = Encriptador.CompararMD5(txtOldPass.Text, cmbUser.SelectedValue.ToString());
            bool nuevaIgual  = txtNewPass.Text.Equals(txtConfirmar.Text);
            bool nuevaValida = txtNewPass.Text.Length > 0;

            if (actualIgual && nuevaIgual && nuevaValida)
            {
                try
                {
                    AppUserDAO.actualizarContra(Convert.ToInt32(cmbUser.Text), Encriptador.CrearMD5(txtNewPass.Text));

                    MessageBox.Show("¡Contraseña actualizada exitosamente!",
                                    "HugoApp - Food Delivery", MessageBoxButtons.OK, MessageBoxIcon.Information);

                    this.Close();
                }
                catch (Exception)
                {
                    MessageBox.Show("¡Contraseña no actualizada! Favor intente mas tarde.",
                                    "Error dialog", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            else
            {
                MessageBox.Show("¡¡Favor verifique que los datos sean correctos!",
                                "Error dialog", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
Example #15
0
        public Resultado Agregar(BE.Usuario pUsuario, int idPermiso)
        {
            pUsuario.Password = Encriptador.EncriptarCadena(pUsuario.Password);

            pUsuario.DVH = GenerarDvh(pUsuario);

            var resultado = _dalManagerUsuario.Insertar(pUsuario);

            if (resultado == ResultadoBd.OK)
            {
                var usuarioBase = _dalManagerUsuario.ObtenerUsuarioPorNombreDeUsuario(pUsuario.NombreUsuario);

                usuarioBase.DVH = GenerarDvh(usuarioBase);

                _dalManagerUsuario.Actualizar(usuarioBase);

                BLL.UsuarioPermiso bllUsuarioPermiso = new UsuarioPermiso();

                //bllUsuarioPermiso.Agregar(new BE.UsuarioPermiso() {IdPermiso = idPermiso, IdUsuario = usuarioBase.Id});
                bllUsuarioPermiso.Agregar(new BE.UsuarioPermiso() {Permiso = new BE.Composite.Permiso(){Id = idPermiso}, Usuario = new BE.Usuario(){Id = usuarioBase.Id}});

                if (ActualizarDvv() == ResultadoBd.OK)
                    return new Resultado(false, "Ok"); 
                else
                {
                    Logger.Log.Error("Error al actualizar el DVV de la tabla usuario.");
                    return new Resultado(true, "Error al actualizar el DVV de la tabla usuario.");
                }
            }

            return new Resultado(false, "No se dio de alta el usuario.");
        }
Example #16
0
        private void buttonUPD_Click(object sender, EventArgs e)
        {
            if (Convert.ToInt32(textId.Text) == 0)
            {
                MessageBox.Show("Seleccione un usuario de la grilla");
            }

            else

            {
                DialogResult Respuesta = MessageBox.Show("Confirma Modificación de Usuario?", "Modificar Usuario", MessageBoxButtons.YesNo);

                if (Respuesta == DialogResult.Yes)
                {
                    try
                    {
                        oUsuario.Id       = Convert.ToInt32(textId.Text);
                        oUsuario.Nombre   = textNombre.Text.Trim();
                        oUsuario.Apellido = textApellido.Text.Trim();
                        oUsuario.Mail     = textMail.Text.Trim();
                        oUsuario.Password = Encriptador.Hash(textPass1.Text);
                        oUsuario.Idioma   = (IdiomaBE)comboIdioma.SelectedItem;

                        bUsuario.Editar(oUsuario);
                    }

                    catch (Exception ex)

                    {
                        MessageBox.Show(ex.Message);
                    }
                }
                CargarGrilla();
            }
        }
Example #17
0
        private Usuario ObtenerUsuarioFormulario()
        {
            try
            {
                //Si es un Alta
                if (usuario == null)
                {
                    usuario = new Usuario();
                }
                else
                {
                    usuario.FechaUltimaModificacion = DateTime.Now; // Ver si tiene que ser parametro de configuración.
                }

                string blancoEncriptado = Encriptador.Encriptar(string.Empty);
                usuario.Username = txtUsername.Text;
                if (Encriptador.Encriptar(txtPassword.Text) != blancoEncriptado)
                {
                    usuario.Password = Encriptador.Encriptar(txtPassword.Text);
                }
                usuario.PreguntaSecreta = txtPregunta.Text;
                if (Encriptador.Encriptar(txtRespuesta.Text) != blancoEncriptado)
                {
                    usuario.RespuestaSecreta = Encriptador.Encriptar(txtRespuesta.Text);
                }
                usuario.Inhabilitado  = chkInhabilitado.Checked;
                usuario.FechaCreacion = (lblFechaCreacion.Text != string.Empty) ? Convert.ToDateTime(lblFechaCreacion.Text) : DateTime.MinValue;
                usuario.Roles         = (List <Rol>)lstAsignados.DataSource;
                return(usuario);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #18
0
        /// <summary>
        ///
        /// </summary>
        public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
        {
            Encriptador _Encriptador = new Encriptador();

            context.OwinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" });
            tblUsuario user;

            using (Entities _repo = new Entities())
            {
                string _encriptedPassword = _Encriptador.Encriptar(context.Password, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
                //string _encriptedPassword = context.Password;
                user = await _repo.tblUsuario.FirstOrDefaultAsync(x => x.Email == context.UserName && x.ClaveUsuario == _encriptedPassword);

                if (user == null)
                {
                    context.SetError("invalid_grant", "The user name or password is incorrect.");
                    return;
                }
            }


            var identity = new ClaimsIdentity(context.Options.AuthenticationType);

            identity.AddClaim(new Claim("Nombre", user.Nombre));
            identity.AddClaim(new Claim("Id", user.IdUsuario.ToString()));

            context.Validated(identity);
        }
Example #19
0
        public RespuestaAtenticacion Autenticar(Usuario usuario)
        {
            Dictionary <string, object> p = new Dictionary <string, object>
            {
                { "alias", usuario.Alias }
            };
            Usuario usuarioEncontrado = usuarioBll.Buscar(p);

            if (usuarioEncontrado == null)
            {
                return(respuestas[RESPUESTA_INCORRECTO]);
            }

            if (usuarioEncontrado.Estado == ESTADO_DESHABILITADO)
            {
                return(respuestas[RESPUESTA_DESHABILITADO]);
            }

            if (usuarioEncontrado.Contrasena == Encriptador.Encriptar(usuario.Contrasena))
            {
                usuarioEncontrado.Reintento = 0;
                usuarioBll.Modificar(usuarioEncontrado);
                return(respuestas[RESPUESTA_CORRECTO]);
            }
            else
            {
                AumentarReintentos(usuarioEncontrado);
                return(respuestas[RESPUESTA_INCORRECTO]);
            }
        }
        private void btnCambiarContra_Click_1(object sender, EventArgs e)
        {
            bool actualIgual = Encriptador.CompararMD5(txtActual.Text, cmbUsuario.SelectedValue.ToString());
            bool nuevaIgual  = txtNueva.Text.Equals(txtRepetir.Text);
            bool nuevaValida = txtNueva.Text.Length > 0;

            if (actualIgual && nuevaIgual && nuevaValida)
            {
                try
                {
                    UsuarioDAO.actualizarContra(cmbUsuario.Text, Encriptador.CrearMD5(txtNueva.Text));

                    MessageBox.Show("¡Contraseña actualizada exitosamente!",
                                    "JUMBO - Bottled coffee", MessageBoxButtons.OK, MessageBoxIcon.Information);

                    this.Close();
                }
                catch (Exception)
                {
                    MessageBox.Show("¡Contraseña no actualizada! Favor intente mas tarde.",
                                    "Error dialog", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            else
            {
                MessageBox.Show("¡¡Favor verifique que los datos sean correctos!",
                                "Error dialog", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
Example #21
0
        public string ResetPassword(int lIdCliente, int lIdUsuario, string lUserName, string lIp)
        {
            string lNewPass = "";

            lNewPass = CreateRandomPassword(10);
            StringBuilder strSqlUpdate = new StringBuilder(128);

            strSqlUpdate.Append("Update Usuarios ");
            strSqlUpdate.Append(" Set Password = "******" Where LoginName = " + StaticDal.Traduce(lUserName));

            StringBuilder strSqlUpdate2 = new StringBuilder(128);

            strSqlUpdate2.Append("INSERT INTO log ");
            strSqlUpdate2.Append("(idTipo, idCliente, idUsuario, evento, ip) VALUES ");
            strSqlUpdate2.Append("(1, " + lIdCliente + ", " + lIdUsuario + ", 'Solicitó cambio de clave', '" + lIp + "') ");
            try
            {
                StaticDal.EjecutarComando(strSqlUpdate.ToString());
                StaticDal.EjecutarComando(strSqlUpdate2.ToString());
            }
            catch
            {
                lNewPass = "";
            }
            return(lNewPass);
        }
Example #22
0
 public Usuario ResetearContrasena(Usuario usuario, string contrasenaNueva)
 {
     usuario.Estado     = ESTADO_DESHABILITADO;
     usuario.Reintento  = 0;
     usuario.Contrasena = Encriptador.Encriptar(contrasenaNueva);
     return(usuarioBll.Modificar(usuario));
 }
Example #23
0
        private void btnConfirmar_Click(object sender, EventArgs e)
        {
            if (!conectorServidor.estaConectado())
            {
                MessageBox.Show("No se pudo establecer conexión con el servidor. Ejecute la aplicación servidor e inicie sesión nuevamente.");
                error = 1;
                this.Close();
                return;
            }

            if (string.IsNullOrWhiteSpace(txtNuevaContrasena.Text))     //Si el campo de la nueva contraseña esta vacio
            {
                MessageBox.Show("Debe ingresar la nueva contraseña");
                return;
            }

            proveedor.Accion           = 5;                                                      //Asigna la accion a realizar, 5 = cambiar contraseña
            proveedor.Contrasena       = Encriptador.crearHashMasSalto(txtNuevaContrasena.Text); //Encripta la contraseña con un hash + salt
            proveedor.Mensaje          = null;
            proveedor.AccionCompletada = false;

            conectorServidor.EnviarAServidor(proveedor);            //Envia el proveedor al servidor

            //Espera respuesta del servidor
            while (conectorServidor.ProveedorRecibido == null)      //Mientras el conector no haya recibido un proveedor
            {
                Thread.Sleep(200);                                  //Espera 200 ms
            }

            proveedor = conectorServidor.ProveedorRecibido;
            conectorServidor.ProveedorRecibido = null;
            this.Hide();                                //Oculta el formulario
        }
Example #24
0
        public static void EnviarEmailContacto(string Nombre, string Email, string Asunto, string Mensaje, ControllerContext _context,
                                               RouteCollection routeCollection, string esquema, string HostName)
        {
            string      Text       = string.Empty;
            string      Html       = string.Empty;
            Encriptador _Encriptar = new Encriptador();

            Text = string.Format(Resources.ContactResource.MensajeEmailClienteTexto, Environment.NewLine, Nombre);

            Html = string.Format(Resources.ContactResource.MensajeEmailClienteHTML
                                 , Resources.ContactResource.HeaderEmailClienteHtml
                                 , Nombre
                                 , Resources.BCMWebPublic.labelAppSlogan);

            string UserID   = string.Empty;
            string Password = string.Empty;
            string SMTPPort = string.Empty;
            string Host     = string.Empty;
            string From     = string.Empty;

            AppSettings(out UserID, out Password, out SMTPPort, out Host, out From);
            SendEmail(From, Resources.ContactResource.SubjectEmailCliente, Html, Text, Email, UserID, Password, SMTPPort, Host, true);

            Text = string.Format(Resources.ContactResource.MensajeEmailApliredTexto, Environment.NewLine, Nombre, Email, Asunto, Mensaje);

            Html = string.Format(Resources.ContactResource.MensajeEmailApliredHTML
                                 , Resources.ContactResource.HeaderEmailApliredHtml
                                 , Nombre
                                 , Email
                                 , Asunto
                                 , Mensaje
                                 , Resources.BCMWebPublic.labelAppSlogan);

            SendEmail(From, Resources.ContactResource.SubjectEmailAplired, Html, Text, Resources.ContactResource.EmailContacto, UserID, Password, SMTPPort, Host, true);
        }
Example #25
0
        public ActionResult Index(string key)
        {
            Encriptador Enc   = new Encriptador();
            string      datos = Enc.Desencriptar(key);

            string[] admin = Regex.Split(datos, "@@");
            string   _key  = Enc.Encriptar(admin[0]);

            Session["admin"]  = _key;
            Session["nombre"] = admin[1];

            /*if (Session["admin"] == null)
             * {
             *  Response.Redirect("/login");
             * }*/
            ListadoArticulos data = new ListadoArticulos();

            data.generaListado(Server.UrlEncode(_key).ToString(), 0);
            ViewBag.listado = data;
            ViewBag.nombre  = Session["nombre"];
            ViewBag.session = Session["admin"];
            ViewBag.key     = key;

            return(View());
        }
Example #26
0
        public JsonResult Crear(UsuarioDto userDto)
        {
            var response = new JsonResponse { Success = false };

            var entityTemp = _usuarioBl.Get(p => p.UserName == userDto.UserName && p.Estado == (int)TipoEstado.Activo);

            if (entityTemp == null)
            {
                var userDomain = MapperHelper.Map<UsuarioDto, Usuario>(userDto);
                Guid guid = Guid.NewGuid();
                var password = guid.ToString().Split('-')[1];
                userDomain.Password = Encriptador.Encriptar(password);

                _usuarioBl.Add(userDomain);

                response.Message = "Se registró el usuario correctamente";
                response.Success = true;
            }
            else
            {
                response.Message = "Ya existe el nombre de usuario";
                response.Success = false;
            }
            return Json(response, JsonRequestBehavior.AllowGet);
        }
        protected void btnSubmit_Click(object sender, EventArgs e)
        {
            if (!Page.IsValid)
            {
                lblError.Text = "Por favor ingrese correctamente los datos de verificación!";
                return;
            }

            //Cargar sobre el objeto global de la clase controladora
            oUsuario = lAdministrador.Usuario_forget(txtUsuario.Text, txtEmail.Text);

            if (oUsuario != null)
            {
                //Update Password:
                string NewPassword = "";
                if (chkNewPass.Checked)
                {
                    NewPassword = Encriptador.EncryptTripleDES(RandomPassword.Generate(8));
                    if (lAdministrador.Usuario_editPassword(oUsuario.IdUsuario, NewPassword))
                    {
                        oUsuario.Password = NewPassword;
                    }
                }

                string urlAdmin = ConfigurationManager.AppSettings["Domain"].ToString() + ConfigurationManager.AppSettings["WebRoot"].ToString() + "admin";
                string Asunto   = "Recuperación de Contraseña";
                string Mensaje  = "<p>Usted ha solicitado recepcionar sus datos de acceso al sistema de administración mediante este correo.</p>";

                Mensaje += "Usuario: " + oUsuario.UserName + "<br>";
                Mensaje += ((chkNewPass.Checked && (oUsuario.Password == NewPassword)) ? "Nueva " : "") + "Contraseña: " + Encriptador.DecryptTripleDES(oUsuario.Password) + "<br>";

                Mensaje += "<p>Para acceder al sistema ingrese desde la siguiente ruta: <a href='http://" + urlAdmin + "'>" + urlAdmin + "</a></p>";
                Mensaje += "<p>Gracias,<br />Administrador del Sistema</p><p>&nbsp;</p>";
                Mensaje += "<p>NOTA:Por favor elimine este correo una vez que haya recepcionado los datos</p>";
                Mensaje += "<p>(*)Este mail ha sido generado automáticamente desde un sistema de información.</p>";

                //Send mail:
                liteCMS.Web.mail.smtpMail smtpMail = new liteCMS.Web.mail.smtpMail();
                smtpMail.FromEmail     = ConfigurationManager.AppSettings["Postmaster"].ToString();
                smtpMail.FromNameEmail = ConfigurationManager.AppSettings["Domain"].ToString();
                smtpMail.ToEmail       = oUsuario.Email;
                smtpMail.ToNameEmail   = oUsuario.Nombres + " " + oUsuario.Apellidos;
                smtpMail.Titulo        = Asunto;
                smtpMail.Subject       = Asunto;
                smtpMail.Texto         = Mensaje;
                smtpMail.setTemplate();
                smtpMail.SendMail();

                //Registrar log de incidencia:
                RegistrarLog(2, "El usuario \"" + oUsuario.UserName + "\" solicitó enviar su contraseña");

                lblEmailResponse.Text     = oUsuario.Email;
                mvwForget.ActiveViewIndex = 1;
            }
            else
            {
                lblError.Text = "El nombre de usuario y el correo no coinciden!";
            }
        }
Example #28
0
        // para la autenticacion
        public void UserRepositoryAccess(string login, string password)
        {
            access = new Access();
            decimal user_id     = 0;
            string  user_email  = "";
            int     user_error  = 1;
            string  code_error  = "";
            string  user_nombre = "";

            string valor1 = "";
            string valor2 = "";
            string key    = "";

            String    _query   = "exec sp_login '" + login + "','" + password + "' ";
            BaseDatos conexion = new BaseDatos("SQL");   //Creando objetos de la base de datos

            conexion.Conectar();
            conexion.CrearComando(_query); //Comando indica que quiero encontrar
            DbDataReader DRConexion = conexion.EjecutarConsulta();

            while (DRConexion.Read())
            {
                user_id     = DRConexion.GetDecimal(0);
                user_email  = DRConexion.GetString(1);
                user_error  = DRConexion.GetInt32(2);
                user_nombre = DRConexion.GetString(3);
            }
            conexion.Desconectar();


            // procesamos token
            if (user_id > 0)
            {
                valor1 = "{\"personaid\":\"" + user_id + "\", \"email\":\"" + user_email + "\", \"error\":\"" + user_error + "\", \"nombre\":\"" + user_nombre + "\"}";
                valor2 = "enia2013";
                // encriptamos el valor
                Encriptador enc = new Encriptador();
                valor1 = enc.Encriptar(valor1);
                //valor2 = enc.Encriptar(valor2);
                key = valor1 + "_" + valor2;
            }

            if (user_error != 0)
            {
                code_error = "Invalid AccessToken";
                key        = "";
            }
            else
            {
                code_error = "Valid AccessToken";
            }

            access = new Access
            {
                //userID = DRConexion.GetDecimal(0),
                token  = key.Replace("+", "%2B").Replace("/", "%2F"),
                codigo = code_error
            };
        }
Example #29
0
    public MySqlConnection conectBDPackage()
    {
        string cadenaConexionEncriptada = ConfigurationManager.ConnectionStrings["conexionKisem"].ToString(); //Toma la cadena de conexión ubicada en el WebConfig
        string cadenaConexion           = Encriptador.desencriptar(cadenaConexionEncriptada);                 //Cadena para desencriptar la cadena conexión

        _Connection = new MySqlConnection(cadenaConexion);
        return(_Connection);
    }
Example #30
0
    static void Main()
    {
        string encriptado    = Encriptador.Encriptar("Hola");
        string desencriptado = Encriptador.Desencriptar("Ipmb");

        Console.WriteLine("Palabra encriptada: {0}", encriptado);
        Console.WriteLine("Palabra desencriptada: {0}", desencriptado);
    }
        public ActionResult CreateUsuario(UsuarioViewModel model)
        {
            if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
                return RedirectToAction("Index", "Home");

            if (!ModelState.IsValid)
            {
                ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
                ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
                return View(model);
            }

            using (SeguricelEntities db = new SeguricelEntities())
            {
                Encriptador Encrypt = new Encriptador();
                Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
                string encryptedPassword = Encrypt.Encriptar(model.PasswordUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);

                Usuario usuario = new Usuario
                {
                    ClaveUsuario = encryptedPassword,
                    Email = model.EmailUsuario,
                    CodigoUsuario = string.Empty,
                    FechaCambioEstatus = DateTime.UtcNow,
                    FechaUltimaConexion = DateTime.UtcNow,
                    IdEstadoUsuario = (int)eEstadoUsuario.Activo,
                    IdTipoUsuario = model.IdTipoUsuario,
                    IdUsuario = Guid.NewGuid(),
                    Nombre = model.Nombre,
                    Pregunta1 = string.Empty,
                    Pregunta2 = string.Empty,
                    Pregunta3 = string.Empty,
                    PrimeraVez = true,
                    Respuesta1 = string.Empty,
                    Respuesta2 = string.Empty,
                    Respuesta3 = string.Empty
                };

                db.Usuario.Add(usuario);
                db.SaveChanges();

                ClasesVarias.AddBitacoraUsuario(db,
                   "Usuario para " + model.Nombre,
                   105000001,
                   "Agregar");

            }
            return RedirectToAction("Usuarios");
        }
        public ActionResult EditUsuario(Guid id)
        {
            if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
                return RedirectToAction("Index", "Home");

            ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
            ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
            UsuarioViewModel model = new UsuarioViewModel();

            using (SeguricelEntities db = new SeguricelEntities())
            {
                Encriptador Encrypt = new Encriptador();
                Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);

                Usuario usuario = (from d in db.Usuario
                                   where d.IdUsuario == id
                                   select d).FirstOrDefault();

                string decryptedPassword = Encrypt.Encriptar(usuario.ClaveUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);
                if (usuario != null)
                {
                    model.ConfirmPasswordUsuario = decryptedPassword;
                    model.EmailUsuario = usuario.Email;
                    model.Estado = usuario.IdEstadoUsuario;
                    model.Id = usuario.IdUsuario;
                    model.IdTipoUsuario = usuario.IdTipoUsuario;
                    model.Nombre = usuario.Nombre;
                    model.PasswordUsuario = decryptedPassword;
                }
            }

            return View(model);
        }
        public ActionResult EditUsuario(UsuarioViewModel model)
        {
            if (User == null || User.GetType().ToString() == "System.Security.Principal.GenericPrincipal")
                return RedirectToAction("Index", "Home");

            if (!ModelState.IsValid)
            {
                ViewBag.Title = Resources.UsuarioSeguridadResource.CreateUsuarioPageTitle;
                ViewBag.PageHeader = Resources.UsuarioSeguridadResource.CreateUsuarioHeaderPage;
                return View(model);
            }

            using (SeguricelEntities db = new SeguricelEntities())
            {
                Encriptador Encrypt = new Encriptador();
                Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
                string encryptedPassword = Encrypt.Encriptar(model.PasswordUsuario, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);

                Usuario usuario = (from d in db.Usuario
                                   where d.IdUsuario == model.Id
                                   select d).FirstOrDefault();

                usuario.ClaveUsuario = encryptedPassword;
                usuario.CodigoUsuario = model.EmailUsuario;
                usuario.Email = model.EmailUsuario;
                usuario.IdTipoUsuario = model.IdTipoUsuario;
                usuario.PrimeraVez = true;
                usuario.Nombre = model.Nombre;

                db.SaveChanges();

                ClasesVarias.AddBitacoraUsuario(db,
                   "Usuario para " + model.Nombre,
                   105000001,
                   "Actualizar");

            }

            return RedirectToAction("Usuarios");
        }
        public ActionResult Checklogin(LoginViewModel model, string returnUrl)
        {
            ViewBag.Title = Resources.LoginResource.PageTitle;
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            // No cuenta los errores de inicio de sesión para el bloqueo de la cuenta
            // Para permitir que los errores de contraseña desencadenen el bloqueo de la cuenta, cambie a shouldLockout: true
            //var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout: false);

            Encriptador Encrypt = new Encriptador();

            using (SeguricelEntities db = new SeguricelEntities())
            {
                Encrypt.InicioClaves("53gur1cel!n37", "4LC_C0MUN1C4C10N35@S3GUR1C3L!N37", "53gur1c3l!4lcC0mun1c4c10n35@s3gur1c3lgm41l!c0m", 5);
                string encryptedPassword = Encrypt.Encriptar(model.Password, Encriptador.HasAlgorimt.SHA1, Encriptador.Keysize.KS256);

                Usuario dataUsuario = (from u in db.Usuario
                                       where (u.CodigoUsuario == model.Email | u.Email == model.Email) && u.ClaveUsuario == encryptedPassword
                                       select u).FirstOrDefault();

                if (dataUsuario != null)
                {
                    switch ((eEstadoUsuario)dataUsuario.IdEstadoUsuario)
                    {
                        case eEstadoUsuario.Conectado:
                        case eEstadoUsuario.Activo:
                            string[] utz = model.UserTimeZone.Split(':');
                            int hourZone;
                            int minZone;
                            if (utz.Length <= 0)
                            {
                                hourZone = 0;
                                minZone = 0;
                            }
                            else
                            {
                                hourZone = int.Parse(utz[0]);
                                minZone = int.Parse(utz[1]);
                            }

                            CustomPrincipalSerializeModel serializeModel = new CustomPrincipalSerializeModel()
                            {
                                Email = dataUsuario.Email,
                                Estado = (eEstadoUsuario)dataUsuario.IdEstadoUsuario,
                                Id = dataUsuario.IdUsuario,
                                FechaUltimaConexion = DateTime.UtcNow,
                                Name = dataUsuario.Nombre,
                                IdTipoUsuario = dataUsuario.IdTipoUsuario,
                                HoursTimeZone = hourZone,
                                MinutesTimeZone = minZone,
                                Culture = Request.UserLanguages[0],
                                DefaultCulture = "es-VE"
                            };

                            string _jsonUserData = JsonConvert.SerializeObject(serializeModel);
                            FormsAuthenticationTicket authTicket =
                                new FormsAuthenticationTicket(1, serializeModel.Email,
                                    DateTime.UtcNow.AddHours(-4).AddMinutes(-30),
                                    DateTime.UtcNow.AddHours(-4).AddMinutes(-15),
                                    false, _jsonUserData);
                            string encTicket = FormsAuthentication.Encrypt(authTicket);
                            HttpCookie faCookie = new HttpCookie(FormsAuthentication.FormsCookieName, encTicket);
                            bool PrimeraVez = false;

                            /*if (dataUsuario.FechaUltimaConexion == null)
                                PrimeraVez = true;*/
                            PrimeraVez = dataUsuario.PrimeraVez;

                            Response.Cookies.Add(faCookie);
                            Session["user"] = encTicket;

                            if (PrimeraVez)
                                return RedirectToAction("Perfil", "Account");
                            else
                            {
                                return ConectarUsuario(dataUsuario, db);
                            }
                        case eEstadoUsuario.Inactivo:
                            ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessageInactivo);
                            break;
                        case eEstadoUsuario.Bloqueado:
                            ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessageBloqueado);
                            break;
                        default:
                            ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessage);
                            break;
                    }
                }
                else
                {
                    ModelState.AddModelError("", Resources.LoginResource.LoginFailedMessage);
                }
            }
            return View(model);

        }