Пример #1
0
        void auth()
        {
            AuthReq auth_req = new AuthReq();

            auth_req.accessKey = accessKey;
            auth_req.subId     = sub_id;
            auth_req.sign      = Encryptor.GetHashSha256(accessKey, sub_id, accessSecret);
            auth_req.subType   = subType;

            TransferPkg pkg = build_TransferPkg((int)CmdId.AuthReq, ProtoBufEncoder.SerializeToBytes(auth_req));

            TransferPkg auth_res = send_and_recv(pkg);

            if (auth_res == null)
            {
                _logger.Error("Authentication failed, received unexpected response, needed AuthRsp, received nothing.");
                reconnect();
                return;
            }
            //check if auth is successful
            if (auth_res.cmdId == (int)CmdId.AuthRsp)
            {
                AuthRsp rsp = ProtoBufDecoder.DeserializeToObj <AuthRsp>(auth_res.data);
                if (rsp.ack == 0)
                {
                    _logger.Info("Authenticated successfully.");
                    //subscribe
                    sub();
                }
                else
                {
                    throw new Exception("Authentication failed, auth info:" + auth_req.ToString());
                }
            }
            else
            {
                _logger.Error("Authentication failed, received unexpected response, needed AuthRsp, received:" + auth_res.cmdId);
            }
        }
Пример #2
0
        public override async Task <AuthRsp> AuthAsync(UserReq user)
        {
            var rsp = new AuthRsp();

            try
            {
                UserReq existing = await this._repo.FindByNameAsync(user.Account);

                if (existing == null)
                {
                    rsp.Status  = -1;
                    rsp.Message = "account not found!";
                    return(rsp);
                }

                string enpass = CryptographyManager.Md5Encrypt(user.Account + "$" + user.Password);

                if (enpass == existing.Password)
                {
                    await this._repo.UpdateLastSenTimeAsync(user.Account, DateTime.Now);

                    rsp.Status  = 0;
                    rsp.Account = user.Account;
                }
                else
                {
                    rsp.Status  = -1;
                    rsp.Message = "wrong account/password";
                }
            }
            catch (Exception ex)
            {
                rsp.Status  = -1;
                rsp.Message = ex.Message;
                Logger.Error("auth error:" + ex.Message + ex.StackTrace);
            }

            return(rsp);
        }
        public async Task Invoke(HttpContext context)
        {
            bool matchLogin   = context.Request.Path.Equals(_option.LoginPath, StringComparison.OrdinalIgnoreCase);
            bool matchCurrent = context.Request.Path.Equals(_option.CurrentPath, StringComparison.OrdinalIgnoreCase);
            bool matchLogout  = context.Request.Path.Equals(_option.LogoutPath, StringComparison.OrdinalIgnoreCase);

            Logger.Debug("request path = {0}", context.Request.Path);
            if (matchLogin)
            {
                context.Response.ContentType = "application/json";
                LoginResult result = new LoginResult();


                var forward    = context.RequestServices.GetRequiredService <IForwardService>();
                var callresult = await forward.ForwardAysnc(context);

                if (callresult.Status != 0)
                {
                    result.Status  = -1;
                    result.Message = callresult.Message;
                    await context.Response.WriteAsync(result.ToString());

                    return;
                }
                AuthRsp rsp = AuthRsp.Parser.ParseJson(callresult.Content);
                if (rsp == null)
                {
                    result.Status  = -1;
                    result.Message = "Server Internal Error ,Wrong Encode!";
                    await context.Response.WriteAsync(result.ToString());

                    return;
                }

                if (rsp.Status != 0)
                {
                    result.Status  = -1;
                    result.Message = rsp.Message;
                    await context.Response.WriteAsync(result.ToString());

                    return;
                }
                const string Issuer = "https://PiggyMetrics.io";
                var          claims = new List <Claim>
                {
                    new Claim(ClaimTypes.Name, rsp.Account, ClaimValueTypes.String, Issuer),
                };

                var userIdentity = new ClaimsIdentity("SuperSecureLogin");
                userIdentity.AddClaims(claims);
                var userPrincipal = new ClaimsPrincipal(userIdentity);

                await context.Authentication.SignInAsync(_option.AuthenticationScheme, userPrincipal,
                                                         new AuthenticationProperties
                {
                    ExpiresUtc   = DateTime.UtcNow.AddMinutes(20),
                    IsPersistent = false,
                    AllowRefresh = false
                });

                result.Status  = 0;
                result.Account = rsp.Account;
                await context.Response.WriteAsync(result.ToString());
            }
            else if (matchCurrent)
            {
                context.Response.ContentType = "application/json";
                LoginResult result = new LoginResult();
                if (!context.User.Identity.IsAuthenticated)
                {
                    result.Status  = -1;
                    result.Message = "Need Authenticate";
                    context.Response.StatusCode = 501;
                }
                else
                {
                    result.Status  = 0;
                    result.Account = context.User.Identity.Name;
                }

                await context.Response.WriteAsync(result.ToString());
            }
            else if (matchLogout)
            {
                context.Response.ContentType = "application/json";
                LoginResult result = new LoginResult();
                await context.Authentication.SignOutAsync(_option.AuthenticationScheme);

                await context.Response.WriteAsync(result.ToString());
            }
            else
            {
                await _next.Invoke(context);
            }
        }