public void BingPhoneExistBing()
{
AccountController account = new AccountController();
ThreeLoginInfo three = new ThreeLoginInfo()
{
openid = "13101200146",
//类型 1 wx,2 qq,3 wb
type = 1,
nickname = "unittest",
};
string token = JWTManager.Encode(three);
SmsController sms = new SmsController();
InputSendSms input = new InputSendSms()
{
phone = "13101200146",
type = EnumSms.itype.BingPhone,
bingtoken = token,
};
smsClear.ClearSms(input.phone);
accountClear.ClearUser(input.phone);
accountClear.AddBing(input.phone, three);
var v1 = sms.GetValidate(input).Data as YJYSoft.YL.Common.AjaxResult;
Assert.IsTrue(v1.code == 0);
var v2 = sms.CheckValidate(input.phone, input.type, "123456", token).Data as YJYSoft.YL.Common.AjaxResult;
Assert.IsTrue(v2.code == 1010203, "已经绑定手机验证失败");
accountClear.ClearUser(input.phone);
}
public void SendBingPhoneExist()
{
ThreeLoginInfo three = new ThreeLoginInfo()
{
openid = "1",
//类型 1 wx,2 qq,3 wb
type = 1
};
string token = JWTManager.Encode(three);
SmsController sms = new SmsController();
InputSendSms input = new InputSendSms()
{
phone = "13101200134",
type = EnumSms.itype.BingPhone,
bingtoken = token
};
//添加用户
smsClear.ClearBingTestUser(input.phone);
smsClear.AddBingTestUser(input.phone, three.type);
var v1 = sms.GetValidate(input).Data as YJYSoft.YL.Common.AjaxResult;
Assert.IsTrue(v1.code == 1010102);
//清除用户
smsClear.ClearBingTestUser(input.phone);
}
static void ListenForToken(TcpClient client)
{
while (MessageFormatter.Connected(client))
{
if (client.GetStream().DataAvailable)
{
string recievedToken = MessageFormatter.ReadStreamOnce(client.GetStream());
Console.WriteLine("Token: " + recievedToken);
if (JWTManager.VerifyToken(recievedToken))
{
//string response = "Token was valid!";
//byte[] data = System.Text.Encoding.ASCII.GetBytes(response);
//byte[] data = BitConverter.GetBytes((int)HttpStatusCode.OK);
byte[] data = MessageFormatter.MessageBytes(HttpStatusCode.OK.ToString());
client.GetStream().Write(data, 0, data.Length);
Console.WriteLine("Valid token response send to {0}", client.Client.RemoteEndPoint.ToString());
}
else
{
//string response = "Token was invalid!";
//byte[] data = System.Text.Encoding.ASCII.GetBytes(response);
//byte[] data = BitConverter.GetBytes((int)HttpStatusCode.Unauthorized);
byte[] data = MessageFormatter.MessageBytes(HttpStatusCode.Unauthorized.ToString());
client.GetStream().Write(data, 0, data.Length);
Console.WriteLine("Invalid token response send to {0}", client.Client.RemoteEndPoint.ToString());
}
}
Thread.Sleep(16);
}
Console.WriteLine("Disconnected");
}
public IHttpActionResult Login([FromBody] UserModel user)
{
var entity = _userRepo.First(new Specification <User>(s => s.Email == user.Email));
var passwordHash = _encryptionService.CreatePasswordHash(user.Password, entity.PasswordSalt);
if (user.Password != entity.Password)
{
return(BadRequest());
}
if (user != null)
{
using (var uow = _unitOfWork.Create())
{
entity.PushToken = user.TokenPush;
}
return(Ok(
new {
token = JWTManager.GenerateToken(entity),
name = entity.UserName
}));
}
else
{
return(BadRequest());
}
}
private async Task <IActionResult> SignInExistingUser(ApplicationUser user, string returnUrl)
{
try
{
var userRoles = await _userManager.GetRolesAsync(user);
var token = JWTManager.GenerateToken(user, userRoles, _tokenConfig);
//await InvalidateToken(Request.Headers[AuthHeaderName]);
//var userClaims = await _claimService.ValidClaimsForUserAsync(user.Id);
string infoAsJson = JsonConvert.SerializeObject(new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
userName = user.UserName,
userEmail = user.Email,
userId = user.Id,
tokenExpiration = token.ValidTo,
roles = userRoles,
//userClaims = _claimService.ClaimsAsDictionary(userClaims)
});
returnUrl += $"?auth={infoAsJson}";
return(Redirect(returnUrl));
}
catch
{
//await AuditService.EditContentAndUserAsync(AuditId, AuditContentType.Activity,
// AuditMessages.Failure.ToString(), user.Id, user.UserName);
returnUrl += $"?error=true";
return(Redirect(returnUrl));
};
}
private static bool ValidateToken(string token, out string username)
{
username = null;
var simplePrinciple = JWTManager.GetPrincipal(token);
var identity = simplePrinciple?.Identity as ClaimsIdentity;
if (identity == null)
{
return(false);
}
if (!identity.IsAuthenticated)
{
return(false);
}
var usernameClaim = identity.FindFirst(ClaimTypes.Name);
username = usernameClaim?.Value;
if (string.IsNullOrEmpty(username))
{
return(false);
}
// More validate to check whether username exists in system
return(true);
}
public HttpResponseMessage Validate(JWTToken token)
{
JWTToken result = new JWTToken()
{
IsValid = false
};
KeyCdr.Users.UserManager userMgr = new Users.UserManager();
var dbUser = userMgr.GetByLoginName(token.UserName);
if (dbUser == null)
{
return(Request.CreateResponse(HttpStatusCode.Forbidden, result));
}
string tokenUsername = new JWTManager().ValidateToken(token.JWTValue);
result.UserName = tokenUsername;
if (token.UserName.Equals(tokenUsername))
{
result.IsValid = true;
return(Request.CreateResponse(HttpStatusCode.OK, result));
}
return(Request.CreateResponse(HttpStatusCode.BadRequest, result));
}
public async Task <IActionResult> Login([Bind("Login, Password")] UserModel user)
{
var tempUser = await _context.Users.Where(u => u.Login == user.Login).FirstOrDefaultAsync();
var results = await ErrorHandler(user, tempUser);
if (!results.IsNullOrEmpty())
{
ViewBag.Error = results;
return(View("Index"));
}
var token = await JWTManager.AssignToken(tempUser);
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
string tokenString = tokenHandler.WriteToken(token);
JwtSecurityToken jwtToken = tokenHandler.ReadJwtToken(tokenString);
HttpContext.Session.SetString("LOGIN", jwtToken.Audiences.ToArray()[0]);
HttpContext.Session.SetString("NICKNAME", tempUser.Nickname);
HttpContext.Session.SetString("TOKEN", tokenString);
HttpContext.Session.SetString("ROLE", jwtToken.Claims.First(x => x.Type.ToString().Equals(ClaimTypes.Role)).Value);
return(RedirectToAction("Index", "Home", new { pageIndex = 1 }));
}
// Start is called before the first frame update
void Start()
{
string[] args = Environment.GetCommandLineArgs();
string token = args[1];
//string token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJKV1RQYXlsb2FkIjoie1wiU2VydmVyc0luZm9cIjp7XCJTZXJ2ZXJzXCI6W119LFwiVXNlcklEXCI6XCJKZW5zXCJ9IiwibmJmIjoxNTcwMTE5MjkwLCJleHAiOjE1NzA1NTEyOTAsImlhdCI6MTU3MDExOTI5MH0.L31Fkm8kaOpVoglhgEv_GvCAD6b1ep0h56OstUnF0d4";
JwtSecurityToken tokenSent = new JwtSecurityToken(token);
JWTPayload payload = JWTManager.GetModelFromToken <JWTPayload>(token);
clientName = payload.UserID;
chatSystem = gameObject.GetComponent <ChatSystem>();
int port = 13001;
//string IpAdress = "10.131.67.203";
client = new TcpClient(Globals.MIDDLEWARE_IP, port);
//client = new TcpClient("192.168.10.135", port);
userName = ((IPEndPoint)client.Client.LocalEndPoint).Address.ToString();
//client.NoDelay = true;
Debug.Log("Connected?");
StartCoroutine(ListenToServer());
}
public string Get(string aadToken)
{
if (CheckUser(aadToken))
{
return(JWTManager.GenerateToken(email));
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public WSObserver get_jwt_connection(string _api_key)
{
if (m_auth_method == null)
{
throw new MyHttpException(403);
}
var _jwt_o = JWTManager.Check(_api_key);
return(m_auth_method.Invoke(null, new object [] { _jwt_o }) as WSObserver);
}
public string GetSession(string username, string password)
{
User u1 = new User();
if ((u1 = CheckUser(username, password)) != null)
{
return(JWTManager.GenerateToken(u1.Username, u1.Role));
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public UserController(JWTManager jwtManager, IUnitOfWork database)
{
_jwtManager = jwtManager;
_database = database;
users.Add(new User {
Id = 1, Name = "jjjj", RoleId = 1
});
roles.Add(new Role {
Id = 1, Name = "plokij"
});
}
public static void AddAuthenticationUser(this IServiceCollection services, IConfiguration Configuration)
{
services.AddTransient <AccountService>();
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x => JWTManager.BuldJWTOption(Configuration, x));
}
public IHttpActionResult GetToken(string username, string password)
{
if (CheckUser(username, password))
{
string token = (JWTManager.GenerateToken(username));
var principal = JWTManager.AuthenticateJwtToken(token);
var i = principal.Result.Identity.Name;
return(Ok((token, i)));
}
return(StatusCode(HttpStatusCode.Unauthorized));
}
public HttpResponseMessage Login([FromBody] LoginCredentials loginCredentials)
{
var userResult = _securityOrchestration.Login(loginCredentials);
if (userResult == null)
{
return(Request.CreateResponse(HttpStatusCode.Forbidden));
}
var newJwtToken = JWTManager.GenerateToken(userResult);
return(Request.CreateResponse(HttpStatusCode.OK, newJwtToken));
}
public IHttpActionResult GetGames()
{
HttpRequestMessage re = Request;
var headers = re.Headers;
if (headers.Contains("Authorization"))
{
string token = headers.GetValues("Authorization").First();
var name = JWTManager.AuthenticateJwtToken(token.Split()[1]).Result.Identity.Name;
return(Ok(name));
}
return(NotFound());
}
public JsonResult GetToken(int clientId, string userName, string password)
{
try
{
log.Info("GetToken method called for client id: " + clientId + " and username: "******"true",
message = "Authentication successful",
access_token = encodedJwt,
expires_in_seconds = (int)TimeSpan.FromMinutes(60).TotalSeconds
};
log.Info("Token generated for client id:" + clientId + " and username: "******"false",
message = "Not authenticated",
access_token = "",
expires_in_seconds = 0
};
log.Info("Client not authenticated client id:" + clientId + " and username: "******"Token generation failed for client id:" + clientId + " and username: "******"false",
message = "Some error occured",
access_token = "",
expires_in_seconds = 0
};
return(Json(responseJson));
}
}
public async Task <IActionResult> Login(UserForLoginDto userForLoginDto)
{
var user = await _authRepository.Login(userForLoginDto.Username, userForLoginDto.Password);
if (user == null)
{
return(Unauthorized());
}
string securityKey = _configuration.GetSection("AppSettings:Token").Value;
string token = JWTManager.CreateToken(user, securityKey);
return(Ok(new { token = token }));
}
public HttpResponseMessage AuthUser(string username, string password)
{
var user = UserManager.Instance.FindUser(username, password);
if (user != null)
{
var token = JWTManager.GetToken(user);
return(Request.CreateResponse(HttpStatusCode.OK, new
{
token = token,
user = user,
details = GetDetails(user.Id, user.AccountType)
}));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Username or password is invalid!"));
}
}
public HttpResponseMessage RefreshToken(string expiredToken)
{
var userId = JWTManager.DecodeToken(expiredToken).Item3;
var user = ApplicationDbContext.Instance.Users.FindOne(x => x.Id == userId);
if (user != null)
{
var token = JWTManager.GetToken(user);
return(Request.CreateResponse(HttpStatusCode.OK, new
{
token = token,
user = user
}));
}
else
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid token."));
}
}
public IResult LogIn(User user, string password)
{
if (user.Password != EncryptProvider.Md5(password))
{
return(new ErrorResult(Messages.User.NotLogIn));
}
var token = JWTManager.GenerateToken(user);
try
{
var db = cache.GetDatabase(0);
db.StringSet($"{token}_user", JsonConvert.SerializeObject(user), TimeSpan.FromDays(1));
}
catch (System.Exception)
{
return(new ErrorResult(Messages.User.NotLogIn));
}
return(new SuccessResult(token));
}
public async Task <IEnumerable <WeatherForecast> > Get()
{
HttpContext.Request.Headers.TryGetValue("Authorization", out StringValues values);
if (values.Any())
{
var t = values.First();
var t1 = t.Split(" ");
var result = JWTManager.ValidateCurrentToken(t1[1]);
}
var rng = new Random();
return(Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray());
}
public void OnActionExecuting(ActionExecutingContext context)
{
if (!context.Filters.Any(x => x.GetType() == typeof(ArduinoAllowAnonymous)))
{
using (IUnitOfWork uow = new UnitOfWork())
{
var token = JWTManager.GetToken(context.HttpContext);
if (String.IsNullOrEmpty(token))
{
UnAuthorized(context);
return;
}
IDataResult <User> existsUser = uow.User.CheckToken(token);
if (!existsUser.Success)
{
UnAuthorized(context);
return;
}
}
}
}
public Responce GetToken(InputAccount inputAccount)
{
var login = inputAccount.Login;
string access_token;
try
{
if (!AccountExists(inputAccount))
{
throw new InvalidOperationException("Invalid username or password!");
}
JWTManager tokenManager = new JWTManager(Configuration);
var typeAccount = GetTypeAccount(login);
access_token = tokenManager.BuldToken(typeAccount, login);
}
catch (Exception ex)
{
return(RespоnceManager.CreateError(ex));
}
return(RespоnceManager.CreateSucces(access_token));
}
public string GetToken(LoginModel loginModel)
{
var userInfo = context.Users.FirstOrDefault(f => f.UserName == loginModel.UserName);
if (userInfo == null)
{
throw new UnauthorizedAccessException();
}
if (userInfo.PasswordHash != loginModel.Password)
{
throw new UnauthorizedAccessException();
}
var companyInfo = context.CompanyInfo.FirstOrDefault(f => f.ID == userInfo.CompanyId);
var token = JWTManager.GenerateToken(userInfo, companyInfo);
return(token);
}
public void BingPhone()
{
AccountController account = new AccountController();
ThreeLoginInfo three = new ThreeLoginInfo()
{
openid = "13101200144",
//类型 1 wx,2 qq,3 wb
type = 1,
nickname = "unittest",
};
string token = JWTManager.Encode(three);
SmsController sms = new SmsController();
InputSendSms input = new InputSendSms()
{
phone = "13101200144",
type = EnumSms.itype.BingPhone,
bingtoken = token,
};
smsClear.ClearSms(input.phone);
accountClear.ClearUser(input.phone);
var v1 = sms.GetValidate(input).Data as YJYSoft.YL.Common.AjaxResult;
Assert.IsTrue(v1.code == 0);
var v2 = sms.CheckValidate(input.phone, input.type, "123456", token).Data as YJYSoft.YL.Common.AjaxResult;
Assert.IsTrue(v2.code == 0, "绑定用户验证短信失败{0}", v2.msg);
var v = Newtonsoft.Json.JsonConvert.SerializeObject(v2.data);
Newtonsoft.Json.JsonConvert.SerializeObject(v2.data);
JObject data = Newtonsoft.Json.JsonConvert.DeserializeObject(v) as JObject;
var v3 = account.SetPwd(data["temptoken"].Value <string>(), input.phone, YJYSoft.YL.Common.Encrypt.MD5Encrypt("123456"), "1", token).Data as YJYSoft.YL.Common.AjaxResult;
Assert.IsTrue(v3.code == 0, "绑定用户失败{0}", v3.msg);
accountClear.ClearUser(input.phone);
}
public JsonResult ValidateToken(string token, string service_name)
{
try
{
bool IsAuthenticated = JWTManager.ValidateToken(token, service_name, out int serviceId);
var responseJson = new
{
auth = IsAuthenticated,
service_id = serviceId
};
return(Json(responseJson));
}
catch (Exception ex)
{
log.Error(ex);
var responseJson = new
{
auth = false,
service_id = 0
};
return(Json(responseJson));
}
}
public FraisController()
{
dataBaseManagerFrais = new DataBaseManagerFrais();
jwtManager = new JWTManager();
}
public void process(FawRequest _req, FawResponse _res)
{
try {
object _obj = null;
if (!m_method.IsStatic)
{
var _jwt_obj = JWTManager.Check(_req.get_header("X-API-Key"));
_obj = m_auth_method.Invoke(null, new object [] { _jwt_obj });
}
//
var _params = new object [m_params.Count];
for (int i = 0; i < m_params.Count; ++i)
{
if (m_params [i].Item1 != null)
{
_params [i] = _req.get_type_value(m_params [i].Item1, m_params [i].Item2);
}
else
{
switch (m_params [i].Item2)
{
case "FawRequest":
_params [i] = _req;
break;
case "FawResponse":
_params [i] = _res;
break;
case ":IP":
_params [i] = _req.m_ip;
break;
case ":AgentIP":
_params [i] = _req.m_agent_ip;
break;
case ":Option":
_params [i] = _req.m_option;
break;
default:
throw new Exception($"{m_name}: Request parameter types that are not currently supported");
}
}
}
var _ret = m_method.Invoke(_obj, _params);
//if (_ret.GetType () == typeof (Task<>)) // 始终为False
if (_ret is Task _t)
{
if (_ret?.GetType() != typeof(Task))
{
//_ret = _ret.GetType ().InvokeMember ("Result", BindingFlags.GetProperty, null, _ret, null);
_ret = (_ret as dynamic).Result;
}
else
{
_t.Wait();
_ret = null;
}
}
if (m_jwt_type == "Gen")
{
var(_o, _exp) = ((object, DateTime))_ret;
_ret = JWTManager.Generate(_o, _exp);
}
if (!_res.has_data())
{
if (_ret != null)
{
if (_ret is byte _byte)
{
_res.write(_byte);
}
else if (_ret is byte [] _bytes)
{
_res.write(_bytes);
}
else
{
string _content = (_ret.GetType().IsPrimitive ? _ret.to_str() : _ret.to_json());
object _o;
if (_content == "")
{
_o = new { result = "success" };
}
else if (_content[0] != '[' && _content[0] != '{')
{
_o = new { result = "success", content = _content };
}
else
{
_o = new { result = "success", content = JToken.Parse(_content) };
}
_res.write(_o.to_json());
}
}
else
{
_res.write(new { result = "success" }.to_json());
}
}
} catch (TargetInvocationException ex) {
if (ex.InnerException != null && ex.InnerException?.GetType() == typeof(Exception))
{
throw ex.InnerException;
}
throw ex;
}
}
