public int SaveClientIDandClientSecret(ClientKeys ClientKeys)
{
_context.ClientKeys.Add(ClientKeys);
//
return(_context.SaveChanges());
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
// TODO: enable https redirects for all production environments
// app.UseHttpsRedirection();
app.Use(async(context, next) =>
{
if (context.Request.Path.Value.StartsWith("/api/"))
{
string key = context.Request.Headers["x-api-key"];
if (key.IsEmpty() || !ClientKeys.ContainsKey(key))
{
context.Response.StatusCode = 401;
return;
}
context.Request.Headers.Add("x-api-client", key.Untagged());
context.Request.Headers.Add("x-api-callback", ClientKeys[key]);
}
await next();
});
app.UseStaticFiles();
app.UseMvc();
}
public void ConfigureAuth(IApplicationBuilder app)
{
IClientKeys keys = new ClientKeys(this.configuration);
app.UseCookieAuthentication(new CookieAuthenticationOptions()
{
AutomaticAuthenticate = true,
AutomaticChallenge = true,
CookieSecure = AspNetCore.Http.CookieSecurePolicy.SameAsRequest,
});
const string Authority = "https://login.microsoftonline.com/common/";
app.UseOpenIdConnectAuthentication(new OpenIdConnectOptions()
{
AutomaticAuthenticate = true,
AutomaticChallenge = true,
ClientId = keys.ClientID,
ClientSecret = keys.ClientSecret,
Authority = Authority,
ResponseType = OpenIdConnectResponseType.CodeIdToken,
SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme,
TokenValidationParameters = new TokenValidationParameters
{
// I believe this is used in multi-tenant applications, if you want to validate a tenant's access to your application
ValidateIssuer = false
},
Events = new OpenIdConnectEvents()
{
OnAuthorizationCodeReceived = async context =>
{
// given the authorization code
var authorizationCode = context.ProtocolMessage.Code;
var request = context.HttpContext.Request;
var redirectUri = new Uri(UriHelper.BuildAbsolute(request.Scheme, request.Host, request.PathBase, request.Path));
// get and verify the access token and refresh token
var credential = new ClientCredential(keys.ClientID, keys.ClientSecret);
var tokenCache = new TokenCache();
var authContext = new AuthenticationContext(Authority, tokenCache);
var result = await authContext.AcquireTokenByAuthorizationCodeAsync(authorizationCode, redirectUri, credential, Keys.Resource);
// serialize the per-user TokenCache
var tokenBlob = tokenCache.Serialize();
// and store it in the authentication properties so that the Controller can access it
context.Properties.Items.Add(Keys.TokenCache, Convert.ToBase64String(tokenBlob));
context.HandleCodeRedemption(result.AccessToken, result.IdToken);
}
}
});
app.UseMvc();
}
public void OnNewClientMessage(Socket sender, MessageClientsStats message)
{
//获取客户端信息
Debug.Log("[服务器]收到一份连接请求");
foreach (ClientKeys tempkey in Clients.Keys)
{
if (tempkey.socket == sender)
{
Clients.Remove(tempkey);
break;
}
}
Socket clientfd = sender;
//自己用的元素
ClientKeys key = new ClientKeys();
ClientStates states = new ClientStates();
ClientState state = new ClientState();
NetworkPartment part = new NetworkPartment();
//发给玩家的信息
MessageClientsStats stats = new MessageClientsStats();
int ID = GetEmptyPlayerNetworkID();
key.NetworkID = ID;
state.NetworkID = ID;
key.socket = clientfd;
part.socket = clientfd;
//交付玩家信息
foreach (ClientStates s in Clients.Values)
{
ClientState FakeStates = new ClientState();
FakeStates.NetworkID = s.State.NetworkID;
FakeStates.IsAlive = s.State.IsAlive;
FakeStates.Stats = s.State.Stats;
FakeStates.NickName = s.State.NickName;
Debug.Log(FakeStates);
Debug.Log(stats);
stats.clients.Add(FakeStates);
}
stats.NetworkID = ID;
stats.PlayerName = message.PlayerName;
stats.clients.Add(state);
stats.MapID = MapID;
//开始整合
state.NickName = message.PlayerName;
states.State = state;
states.Network = part;
//添加客户端
Clients.Add(key, states);
//广播消息
BroadcastingMessage(JsonUtility.ToJson(stats));
}
public void OnMoveMessage(MessageMove message)
{
ClientKeys key = GetClientKeyInformation(message.NetworkID);
Clients [key].State.Stats.Position = message.Position;
Clients [key].State.Stats.Rotation = Quaternion.Euler(message.Rotation);
string s = JsonUtility.ToJson(message);
BroadcastingMessage(s);
}
public void ReadListenfd(Socket listenfd)
{
ClientKeys key = new ClientKeys();
key.socket = listenfd.Accept();
ClientStates state = new ClientStates();
state.Network = new NetworkPartment();
Clients.Add(key, state);
}
public ClientKeys GetClientKeyInformation(Socket socket)
{
ClientKeys key = null;
foreach (ClientKeys k in Clients.Keys)
{
if (k.socket == socket)
{
key = k;
break;
}
}
return(key);
}
public ClientKeys GetClientKeyInformation(int i)
{
ClientKeys key = null;
foreach (ClientKeys k in Clients.Keys)
{
if (k.NetworkID == i)
{
key = k;
break;
}
}
return(key);
}
public bool ReadClientfd(Socket clientfd)
{
//获取目标
ClientKeys key = null;
foreach (ClientKeys k in Clients.Keys)
{
if (k.socket == clientfd)
{
key = k;
break;
}
}
ClientStates state = Clients[key];
//接收
int count = 0;
try
{
state.Network.ReadBuff = new byte[65535];
count = clientfd.Receive(state.Network.ReadBuff);
DecodeMessage(clientfd, state.Network.ReadBuff, count);
}
catch (SocketException ex)
{
MessageLeaveGame message = new MessageLeaveGame(key.NetworkID);
BroadcastingMessage(JsonUtility.ToJson(message));
clientfd.Close();
Clients.Remove(key);
Debug.Log("[服务端]信息接收失败！连接被迫关闭,错误信息：" + ex.ToString());
return(false);
}
//客户端关闭
if (count == 0)
{
MessageLeaveGame message = new MessageLeaveGame(key.NetworkID);
BroadcastingMessage(JsonUtility.ToJson(message));
clientfd.Close();
Clients.Remove(key);
Debug.Log("[服务端]收到一条连接关闭请求");
return(false);
}
return(true);
}
public bool IsAppValid(ClientKeys clientkeys)
{
bool flags = true;
var app = _context.RegisterApps.Where(c => c.RegisterAppId == clientkeys.RegisterAppId).FirstOrDefault();
if (app != null)
{
if (app.TotalAppCallLimit == 0)
{
flags = false;
}
}
else
{
}
return(flags);
}
public HttpResponseMessage Authenticate(string ClientId, string ClientSecret)
{
ClientKeys ClientKeys = new ClientKeys()
{
ClientId = ClientId, ClientSecret = ClientSecret
};
if (string.IsNullOrEmpty(ClientKeys.ClientId) && string.IsNullOrEmpty(ClientKeys.ClientSecret))
{
HttpResponseMessage response = new HttpResponseMessage();
response = Request.CreateResponse(HttpStatusCode.NotAcceptable, "Not Valid Request");
return(response);
}
else if (_IAuthenticate.ValidateKeys(ClientKeys))
{
var clientkeys = _IAuthenticate.GetClientKeysDetailsbyCLientIDandClientSecret(ClientKeys.ClientId, ClientKeys.ClientSecret);
if (clientkeys == null)
{
HttpResponseMessage response = new HttpResponseMessage();
response = Request.CreateResponse(HttpStatusCode.NotFound, "InValid Keys");
return(response);
}
else
{
if (_IAuthenticate.IsTokenAlreadyExists(clientkeys.RegisterAppId.Value))
{
_IAuthenticate.DeleteGenerateToken(clientkeys.RegisterAppId.Value);
return(GenerateandSaveToken(clientkeys));
}
else
{
return(GenerateandSaveToken(clientkeys));
}
}
}
else
{
HttpResponseMessage response = new HttpResponseMessage();
response = Request.CreateResponse(HttpStatusCode.NotFound, "InValid Keys");
return(response);
}
}
public string GenerateToken(ClientKeys ClientKeys, DateTime IssuedOn)
{
try
{
string randomnumber =
string.Join(":", new string[]
{ Convert.ToString(ClientKeys.UserID),
KeyGenerator.GetUniqueKey(),
Convert.ToString(ClientKeys.RegisterAppId),
Convert.ToString(IssuedOn.Ticks),
ClientKeys.ClientId });
return(EncryptionLibrary.EncryptText(randomnumber));
}
catch (Exception)
{
throw;
}
}
private static async Task ClientKeys(ClientKeys options)
{
var configuration = Configuration.GetConfiguration();
var redis = ConnectionMultiplexer.Connect(configuration["RedisConnectionString"]);
var server = redis.GetServer(configuration["RedisInstance"]);
var clients = server.ClientList();
Console.WriteLine("Redis Connections");
Console.WriteLine("");
Console.WriteLine("{0,-50}{1,-20}", "Client Name", "Connection count");
Console.WriteLine("{0,-50}{1,-20}", "-------------------------------------", "----------------------");
foreach (var client in clients
.GroupBy(g => g.Name, (key, g) => new { Name = key, Count = g.Count() })
.OrderByDescending(o => o.Count))
{
Console.WriteLine("{0,-50}{1,-20}", client.Name, client.Count);
}
}
public ClientKeys CreateApp(RegisterApp app, string userId, bool keyExists, IRegisterApp appRegistrar, IClientKeys clientKeyToolkit, int appCallLimit)
{
app.UserID = userId;
app.CreatedOn = DateTime.Now;
app.TotalAppCallLimit = appCallLimit;
appRegistrar.Add(app); // this code fills RegisterAppId and adds the app to db, and should always auto-increment model.RegisterAppId to > 0
// Generate Clientid and Secret Key
// Validating ClientID and ClientSecret already Exists
ClientKeys clientkeys;
if (keyExists)
{
// Getting Generate ClientID and ClientSecret Key By UserID
clientkeys = clientKeyToolkit.GetGenerateUniqueKeyByUserID(userId);
}
else
{
// reload app from DB
app = appRegistrar.FindAppByUserId(userId);
// Generate Keys
String clientSecret, clientID;
clientKeyToolkit.GenerateUniqueKey(out clientID, out clientSecret);
// Saving Keys Details in Database
clientkeys = new ClientKeys();
clientkeys.ClientKeysID = 0;
clientkeys.RegisterAppId = app.RegisterAppId;
clientkeys.CreatedOn = DateTime.Now;
clientkeys.ClientId = clientID;
clientkeys.ClientSecret = clientSecret;
clientkeys.UserID = userId;
clientKeyToolkit.SaveClientIDandClientSecret(clientkeys);
// MC121517 quick and dirty hack to address the bug at app creation in ManageApp.cshtml where RegisterApps is null in @clientkeys.RegisterApps.Name
// otherwise ManageApp.cshtml will crash
clientkeys.RegisterApps = app;
}
return(clientkeys);
}
public bool ValidateKeys(ClientKeys ClientKeys)
{
try
{
var result = (from clientkeys in _context.ClientKeys
where clientkeys.ClientId == ClientKeys.ClientId && clientkeys.ClientSecret == ClientKeys.ClientSecret
select clientkeys).Count();
if (result > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception)
{
throw;
}
}
private HttpResponseMessage GenerateandSaveToken(ClientKeys clientkeys)
{
var IssuedOn = DateTime.Now;
var newToken = _IAuthenticate.GenerateToken(clientkeys, IssuedOn);
var result = _IAuthenticate.InsertToken(clientkeys, ConfigurationManager.AppSettings["TokenExpiry"], newToken);
if (result == 1)
{
HttpResponseMessage response = new HttpResponseMessage();
response = Request.CreateResponse(HttpStatusCode.OK, newToken);
response.Headers.Add("Token", newToken);
response.Headers.Add("TokenExpiry", ConfigurationManager.AppSettings["TokenExpiry"]);
response.Headers.Add("Access-Control-Expose-Headers", "Token,TokenExpiry");
return(response);
}
else
{
HttpResponseMessage response = new HttpResponseMessage();
response = Request.CreateResponse(HttpStatusCode.NotAcceptable, "Error in Creating Token");
return(response);
}
}
public int InsertToken(ClientKeys clientkeys, string tokenExpiry, string newToken)
{
try
{
//
var IssuedOn = DateTime.Now;
TokensManager token = new TokensManager();
token.TokensManagerID = 0;
token.TokenKey = newToken;
token.RegisterAppId = clientkeys.RegisterAppId;
token.IssuedOn = IssuedOn;
token.ExpiresOn = DateTime.Now.AddMinutes(Convert.ToInt32(tokenExpiry));
token.CreaatedOn = DateTime.Now;
_context.TokensManager.Add(token);
return(_context.SaveChanges());
}
catch (Exception)
{
throw;
}
}
public string GetToken(ClientKeys clientKeys, IAuthenticate authenticater, String tokenExpiry, out String sessiontoken)
{
//
sessiontoken = null;
//
if (string.IsNullOrEmpty(clientKeys.ClientId) && string.IsNullOrEmpty(clientKeys.ClientSecret))
{
return("Not Valid Request");
}
//
string result = string.Empty;
if (authenticater.ValidateKeys(clientKeys))
{
var clientkeys = authenticater.GetClientKeysDetailsbyCLientIDandClientSecret(clientKeys.ClientId, clientKeys.ClientSecret);
if (clientkeys == null)
{
return("InValid Keys");
}
else
{
if (authenticater.IsTokenAlreadyExists(clientkeys.RegisterAppId.Value))
{
authenticater.DeleteGenerateToken(clientkeys.RegisterAppId.Value);
var IssuedOn = DateTime.Now;
var newToken = authenticater.GenerateToken(clientkeys, IssuedOn);
var status = authenticater.InsertToken(clientkeys, tokenExpiry, newToken);
if (status == 1)
{
// Session["_T0k@n_"] = newToken;
sessiontoken = newToken;
result = "Token generated successfully !!!";
}
else
{
result = "Error in Creating Token";
}
}
else
{
var issuedOn = DateTime.Now;
var newToken = authenticater.GenerateToken(clientkeys, issuedOn);
var status = authenticater.InsertToken(clientkeys, tokenExpiry, newToken);
if (status == 1)
{
// Session["_T0k@n_"] = newToken;
sessiontoken = newToken;
result = "Token generated successfully !!!";
}
else
{
result = "Error in Creating Token";
}
}
}
}
else
{
result = "Invalid Keys!!!";
}
return(result);
}
public int UpdateClientIDandClientSecret(ClientKeys ClientKeys)
{
_context.Entry(ClientKeys).State = EntityState.Modified;
_context.SaveChanges();
return(_context.SaveChanges());
}
