public bool advance() { Line L = Line; TokenObject tok = TokenObj; if (tok.TokenCategory == TokenCategory.tokEOF) { // we are already at EOF if (Echo) { Console.Write("<EOF>"); } return(false); } if (Echo) { Console.Write(tok.WhiteSpace); Console.Write(tok.theToken); } TokNo++; if (TokNo < Line.TheLine.Count) { // we are now at next token on the same line return(true); } TokNo = 0; LineNo++; if (LineNo >= TokFile.File.Count) { // There is probably a bug somewhere as we ran out of lines & tokens but didnt meet an EOF. return(false); } // we are now at next token on the same line return(true); }
public async Task <TokenResponse> Login([FromBody] LoginRequest loginModel) { ResponseMessage <User> request = _securityService.FindByCredencials(loginModel.Email, loginModel.Password); if (!request.IsSuccess) { throw new HttpStatusCodeException(HttpResponseType.BadRequest, request.ErrorMessage); } else if (request.IsSuccess && request.ResponseObject == null) { throw new HttpStatusCodeException(HttpResponseType.Unauthorized, "Unauthorized"); } else if (request.ResponseObject.Deactivated) { throw new HttpStatusCodeException(HttpResponseType.Unauthorized, "Deactivated!"); } TokenObject tokenObject = await _tokenStoreService.CreateJwtTokens(request.ResponseObject).ConfigureAwait(false); TokenResponse token = new TokenResponse { access_token = tokenObject.Token, expires_in = TimeSpan.FromDays(5).TotalSeconds }; return(token); }
public BusinessContextController(IProgressConnection connection, ICacheWrapper appCache) { this.connection = connection; this._appCache = appCache; this._tokenObject = ApplicationCookieUtilities.Principal(HttpContext.Current.User, out var _); this._appCache.TokenObject = this._tokenObject; }
private static bool CheckZeroMany(LineObject lineObject, bool printFlag, CheckSt st, LexRecord lexObj, CheckObject checkObject, UpdateLex updateLex, bool checkLength) { lineObject.SetGoToNext(true); st.UpdateLastState(); bool flag = checkObject.IsNextStartStr(lineObject.GetLine()); if (flag == true) { st.UpdateCurState(checkObject.GetNextState()); lineObject.SetGoToNext(false); return(flag); } flag = LineCheck.CheckStartStr(lineObject, printFlag, checkObject); if (flag == true) { TokenObject tokenObject = new TokenObject(); flag = LineCheck.CheckSlotFiller(lineObject, printFlag, checkObject, tokenObject, checkLength); if (flag == true) { updateLex.Update(lexObj, tokenObject.GetToken()); } } return(flag); }
public void KeywordFail() { Tokenizer t = new Tokenizer(StringToStream("random")); TokenObject k = t.GetToken(); Assert.NotNull(k); Assert.True(k is TokenError); }
public static void put(string repositoryId, string user, TokenObject tokenObject) { if (!store.ContainsKey(repositoryId)) { store.Add(repositoryId, new RepositoryStore(repositoryId)); } store[repositoryId].put(user, tokenObject); }
public JsonViewService(AssharedinquiryRepository assharedinquiryRepository, AssharedentryRepository assharedentryRepository, PvUserRepository pvUserRepository, SastaRepository sastaRepository) { this._assharedinquiryRepository = assharedinquiryRepository; this._assharedentryRepository = assharedentryRepository; this._pvUserRepository = pvUserRepository; this._sastaRepository = sastaRepository; string myhost; this._tokenObject = ApplicationCookieUtilities.Principal(HttpContext.Current.User, out myhost); }
public void put(string user, TokenObject tokenObject) { if (tokenDict.ContainsKey(user)) { tokenDict[user] = tokenObject; } else { tokenDict.Add(user, tokenObject); } }
public List <Token> GetTokens() { List <Token> tokens = new List <Token>(); TokenObject tk = JsonConvert.DeserializeObject <TokenObject>(Get("tokens")); foreach (Token t in tk.tokens) { tokens.Add(t); } return(tokens); }
public static void put(string repositoryId, string user, TokenObject tokenObject) { RepositoryStore repoStore = store[repositoryId]; if(repoStore == null) { store[repositoryId] = new RepositoryStore(repositoryId); repoStore = store[repositoryId]; } repoStore.put(user, tokenObject); }
public void KeywordFailIdentifiers() { Tokenizer t = new Tokenizer(StringToStream("random")) { AllowIdentifiers = true }; TokenObject k = t.GetToken(); Assert.NotNull(k); Assert.True(k is TokenIdentifier); Assert.True(t.GetToken() is TokenEmpty); }
public void TokenIsValid() { var ticks = SystemTime.UtcNow().Ticks; const string secKey = "DF25BCB5-35E3-41E4-980F-64D916D806FF"; const string appId = "87E9DAAB-2EA4-4A99-92BA-6C9DDB0F868C"; TokenObject token = TokenObject.Create( TokenObject.Token(appId, ticks, secKey), appId, ticks); Assert.IsTrue(token.IsValid(secKey)); }
public void writeTo(TextWriter Dest) { for (int i = 0; i < File.Count; i++) { Line L = File[i]; for (int j = 0; j < L.TheLine.Count; j++) { TokenObject T = L.TheLine[j]; Dest.Write(T.WhiteSpace); Dest.Write(T.theToken); } } }
private async Task <List <string> > GetTracksName(string tracksHREF, TokenObject token) { var rootTracks = new RootTracks(); var client = new HttpClient(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token.access_token); using (var resp = await client.GetAsync(tracksHREF)) { string apirespjson = await resp.Content.ReadAsStringAsync(); rootTracks = JsonConvert.DeserializeObject <RootTracks>(apirespjson); return(rootTracks.items.Select(s => s.track.name).ToList()); } }
/// <summary> /// /// </summary> /// <param name="publicKey"></param> /// <param name="ticks"></param> /// <param name="secretKey"></param> /// <returns></returns> public static CredentialData CreateToken(string publicKey, Int64 ticks, string secretKey) { var credential = new CredentialData { ClientType = ClientType.Node.ToName(), CredentialType = CredentialType.Token.ToName(), ClientId = publicKey, Ticks = ticks, UserName = "******" }; credential.Password = TokenObject.Token(publicKey, ticks, secretKey); return(credential); }
public ActionResult <string> Login([FromBody] User suggestedUser) { bool validUser = CheckCredentials(suggestedUser); if (validUser) { ITokenIssuer tokenIssuer = ModelFactory.NewTokenIssuer(Configuration); TokenObject token = new TokenObject(tokenIssuer.GetToken()); return(Ok(token)); } else { return(Unauthorized()); } }
public async Task<IActionResult> Refresh([FromBody] TokenObject tokenObject) { var handler = new JwtSecurityTokenHandler(); var principal = handler.ReadToken(tokenObject.Token) as JwtSecurityToken; var email = principal.Claims.FirstOrDefault(claim => claim.Type == JwtRegisteredClaimNames.Email)?.Value; var user = await userManager.FindByEmailAsync(email); if (user.RefreshToken != tokenObject.RefreshToken) { return BadRequest("Invalid refresh token"); } var newJwtToken = await jwtFactory.GenerateEncodedToken(user); var newRefreshToken = jwtFactory.GenerateRefreshToken(); user.RefreshToken = newRefreshToken; await userManager.UpdateAsync(user); return Ok(new TokenObject { Token = newJwtToken, RefreshToken = newRefreshToken }); }
protected void Application_AuthenticateRequest(Object sender, EventArgs e) { // PMC 07/16/2016 - IBM AppScan - This has been manually reviewed and passed as being safe // Encrypted Token is validated. Any issues will cause the request to be returned as 401 Unauthorized var tokenObject = new TokenObject(); var token = this.Context.Request.Headers[ApplicationCookieUtilities.TokenName]; if (!string.IsNullOrEmpty(token)) { var progressSettings = DependencyResolver.Current.GetService <IProgressConfiguration>(); ApplicationCookieUtilities.TokenToObject(token, progressSettings.ApplicationEncryptKey, progressSettings.ApplicationEncryptIv, out tokenObject); } var callGuid = this.Context.Request.Headers[ApplicationCookieUtilities.CallGuidName]; var bearerToken = this.Context.Request.Headers[ApplicationCookieUtilities.BearerToken]; var serviceInterfacePrincipal = new ServiceInterfacePrincipal(tokenObject, this.Context.Request.Url.Host, this.Context.Request.UrlReferrer, new ProgressConfiguration().SSoEnabled ? Thread.CurrentPrincipal.Identity : new GenericIdentity(tokenObject.Oper), callGuid, bearerToken); this.Context.User = serviceInterfacePrincipal; }
private async Task LoginButton_Clicked(object sender, EventArgs e) { LoginButton.IsEnabled = false; LoginIndicator.IsRunning = true; res = await apiService.Login(name.Text, password.Text); if (res.IsSuccessStatusCode) { var contents = await res.Content.ReadAsStringAsync(); TokenObject tokenObject = JsonConvert.DeserializeObject <TokenObject>(contents); //memService.SaveString("trainingmaster_token", tokenObject.access_token); Application.Current.Properties["trainingmaster_token"] = tokenObject.access_token; res = await apiService.GetUserInfo(); if (res.IsSuccessStatusCode) { contents = await res.Content.ReadAsStringAsync(); User user = JsonConvert.DeserializeObject <User>(contents); if (user == null) { await Error("User not found"); } else { memService.SerializeUser(user); //Application.Current.MainPage = new MainPage(); SetMainPage(); } } else { await Error("Something went wrong : " + res.StatusCode); } } else { await Error("Something went wrong : " + res.StatusCode); } LoginButton.IsEnabled = true; LoginIndicator.IsRunning = false; }
/// <summary>Print info</summary> /// <returns></returns> public override string ToString() { StringBuilder sb = new StringBuilder(); if (TokenObject != null) { sb.Append(TokenObject.ToString()); } if (Key != null || Patterns != null) { sb.Append("Token("); sb.Append(TokenObject?.ToString()); if (Key != null) { sb.Append(", Key="); sb.Append(Key); } if (Patterns != null) { if (Key != null) { sb.Append(", "); } if (Patterns.Length == 1) { sb.Append("Patters="); sb.Append(Patterns[0]); } else { sb.Append("Patterns=["); for (int i = 0; i < Patterns.Length - 1; i++) { if (i > 0) { sb.Append(", "); } sb.Append(Patterns[i]); } sb.Append("]"); } } sb.Append(')'); } return(sb.ToString()); }
private async Task <TokenObject> CreateAccessTokenAsync(List <Claim> claims) { //generate token SymmetricSecurityKey key = new SymmetricSecurityKey(TokenStoreSecurityService.GetSha256Hash(_jwtOptions.Key)); SigningCredentials creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256); JwtSecurityToken token = new JwtSecurityToken( issuer: _jwtOptions.Issuer, audience: _jwtOptions.Audience, claims: claims, notBefore: DateTime.UtcNow, expires: DateTime.UtcNow.AddDays(5), signingCredentials: creds); TokenObject tokenObject = new TokenObject { Token = new JwtSecurityTokenHandler().WriteToken(token) }; return(await Task.FromResult(tokenObject)); }
public async Task <IActionResult> GetRefreshToken([FromBody] TokenObject tokenfromQuerystring) { var requestContent = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("grant_type", "refresh_token"), new KeyValuePair <string, string>("refresh_token", tokenfromQuerystring.RefreshToken) }); using var response = await _client.PostAsync("https://accounts.spotify.com/api/token", requestContent); if (response.IsSuccessStatusCode) { var responseContent = await response.Content.ReadAsStringAsync(); TokenObject tokenObject = (TokenObject)JsonSerializer.Deserialize(responseContent, typeof(TokenObject)); return(Ok(tokenObject)); } return(Unauthorized("perform authorization again")); }
private TokenObject GetClientCredentialsAuthToken() { var webClient = new WebClient(); var postparams = new NameValueCollection(); postparams.Add("grant_type", "client_credentials"); var authHeader = Convert.ToBase64String(Encoding.Default.GetBytes($"{Settings.SpotifyClientId}:{Settings.SpotifyClientSecret}")); webClient.Headers.Add(HttpRequestHeader.Authorization, "Basic " + authHeader); var tokenResponse = webClient.UploadValues("https://accounts.spotify.com/api/token", postparams); var textResponse = Encoding.UTF8.GetString(tokenResponse); var token = new TokenObject(); token = JsonConvert.DeserializeObject <TokenObject>(textResponse); return(token); }
public IntegrationService(ICacheWrapper appCache, CoudSuiteWebClient webClient, IProgressConnection connection, IProgressConfiguration progressConfiguration) { this._appCache = appCache; this._connection = connection; this._progressConfiguration = progressConfiguration; this._tokenObject = ApplicationCookieUtilities.Principal(HttpContext.Current.User, out _); this._appCache.TokenObject = this._tokenObject; _supportedRepositories = new Dictionary <string, SupportedRespository> { { "icsw", new SupportedRespository { IdmEntityType = "Item_Images", IdmRepository = "icsw", Formatter = "@Product_Number = \"{0}\"" } } }; this._bearerToken = StringProtector.Unprotect(ApplicationCookieUtilities.BearerTokenValue(HttpContext.Current.User), new ProgressConfiguration().ApplicationEncryptKey, new ProgressConfiguration().ApplicationEncryptIv); }
public async Task <TokenResponse> RegisterVisitor([FromBody] RegisterUserRequest data) { //TODO: Telefon hozzárendelése a felhasználóhoz ResponseMessage <User> request = _securityService.Create(data); if (!request.IsSuccess) { throw new HttpStatusCodeException(HttpResponseType.BadRequest, request.ErrorMessage); } TokenObject tokenObject = await _tokenStoreService.CreateJwtTokens(request.ResponseObject).ConfigureAwait(false); TokenResponse token = new TokenResponse { access_token = tokenObject.Token, expires_in = TimeSpan.FromDays(5).TotalSeconds }; return(token); }
public ActionResult <TokenObject> Registry([FromBody] User user) { if (ModelState.IsValid) { string username = user.Username; string password = user.Password; var identity = GetIdentity(username, password); if (identity == null) { //return BadRequest(new { errorText = "401" }); return(StatusCode(401)); } var now = DateTime.UtcNow; // создаем JWT-токен var jwt = new JwtSecurityToken( issuer: AuthOptions.ISSUER, audience: AuthOptions.AUDIENCE, notBefore: now, claims: identity.Claims, expires: now.Add(TimeSpan.FromMinutes(AuthOptions.LIFETIME)), signingCredentials: new SigningCredentials(AuthOptions.GetSymmetricSecurityKey(), SecurityAlgorithms.HmacSha256)); var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt); var response = new { access_token = encodedJwt, username = identity.Name }; TokenObject tokenObject = new TokenObject(); tokenObject.Token = response.access_token; tokenObject.Login = response.username; return(tokenObject); } return(BadRequest()); }
public void NotAuthorized() { var xm = NewXM(); var keys = new string[] { "XM", "ZZJGM" }; var values = new string[] { xm, "11011421004" }; var infoValue = new KeyValueBuilder(keys, values).ToArray(); var client = new JsonServiceClient(AcDomain.NodeHost.Nodes.ThisNode.Node.AnycmdApiAddress); var ticks = DateTime.UtcNow.Ticks; var request = new Message { MessageId = System.Guid.NewGuid().ToString(), Version = "v1", MessageType = "action", IsDumb = true, Verb = Verb.Create.Code, Ontology = "JS", Body = new BodyData(infoValue, infoValue), Credential = new CredentialData { ClientType = ClientType.Node.ToName(), CredentialType = CredentialType.Token.ToName(), ClientId = "41e711c6-f215-4606-a0bf-9af11cce1d54", Ticks = ticks, Password = TokenObject.Token("41e711c6-f215-4606-a0bf-9af11cce1d54", ticks, "invalidSecretKey") }, TimeStamp = DateTime.UtcNow.Ticks }; var response = client.Get(request); Assert.IsTrue(Status.NotAuthorized.ToName() == response.Body.Event.ReasonPhrase, response.Body.Event.Description); request.Verb = "Get"; request.JspxSignature();// 签名 var result = request.RequestNode(AcDomain.NodeHost.Nodes.CenterNode); Assert.IsTrue((int)Status.NotExist == result.Body.Event.Status, result.Body.Event.Description); }
public static IEnumerator FetchToken( string url, string channel, int userId, Action <string> callback = null ) { UnityWebRequest request = UnityWebRequest.Get(string.Format( "{0}/rtc/{1}/publisher/uid/{2}/", url, channel, userId )); yield return(request.SendWebRequest()); if (request.isNetworkError || request.isHttpError) { Debug.Log(request.error); callback(null); yield break; } TokenObject tokenInfo = JsonUtility.FromJson <TokenObject>( request.downloadHandler.text ); callback(tokenInfo.rtcToken); }
public async Task GetAuthorization() { var queryDict = HttpContext.Request.Query; if (queryDict.ContainsKey("error")) { //send error response Response.Redirect($"{Request.Scheme}://{Request.Host}/main?error={queryDict["error"]}"); return; } var requestContent = new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("grant_type", "authorization_code"), new KeyValuePair <string, string>("code", WebUtility.UrlEncode(queryDict["code"])), new KeyValuePair <string, string>("redirect_uri", $"{Request.Scheme}://{Request.Host}/{_configuration["Spotify:RedirectPath"]}") }); using var response = await _client.PostAsync("https://accounts.spotify.com/api/token", requestContent); if (response.IsSuccessStatusCode) { var responseContent = await response.Content.ReadAsStringAsync(); TokenObject tokenObject = (TokenObject)JsonSerializer.Deserialize(responseContent, typeof(TokenObject)); Response.Redirect($"{Request.Scheme}://{Request.Host}/callback?access_token={tokenObject.AccessToken}&refresh_token={tokenObject.RefreshToken}"); return; } var resMsg = await response.Content.ReadAsStringAsync(); _logger.LogInformation(resMsg); Response.Redirect($"{Request.Scheme}://{Request.Host}/callback?error=invalid_token"); }
private TokenObject GenerateToken(ClaimsIdentity Identity) { DateTime now = DateTime.UtcNow; var tokenExpirationMins = _options.Value.TokenExpirationInMinutes; var issuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(GetOptions.Secret)); var jwtToken = new JwtSecurityToken( issuer: GetOptions.Issuer, audience: GetOptions.Audience, claims: Identity.Claims, notBefore: now, expires: now.AddMinutes(tokenExpirationMins), signingCredentials: new SigningCredentials(issuerSigningKey, SecurityAlgorithms.HmacSha256) ); var encodedToken = new JwtSecurityTokenHandler().WriteToken(jwtToken); TokenObject tokenObject = new TokenObject { Token = encodedToken, Expiration = tokenExpirationMins }; return(tokenObject); }
public static extern bool OpenProcessToken(IntPtr processHandle, TokenObject desiredAccess, out IntPtr tokenHandle);
public CurrencyConverterService(TokenObject tokenObject) { apiKey = tokenObject.CurrencyConverterApi; }
public void put(string user, TokenObject tokenObject) { tokenDict[user] = tokenObject; }
/// <summary> /// /// </summary> /// <param name="cmdDto"></param> /// <param name="toNode"></param> /// <returns></returns> public static IMessageDto RequestNode(this IMessageDto cmdDto, NodeDescriptor toNode) { if (cmdDto == null) { throw new ArgumentNullException("cmdDto"); } if (toNode == null) { throw new ArgumentNullException("toNode"); } if (cmdDto.Credential == null) { throw new GeneralException("非法状态的命令,没有设置证书"); } if (string.IsNullOrEmpty(cmdDto.Credential.Password)) { CredentialType credentialType; if (!cmdDto.Credential.CredentialType.TryParse(out credentialType)) { throw new GeneralException("意外的证书类型" + cmdDto.Credential.CredentialType); } ClientType clientType; if (!cmdDto.Credential.ClientType.TryParse(out clientType)) { throw new GeneralException("意外的客户端类型" + cmdDto.Credential.ClientType); } switch (clientType) { case ClientType.Undefined: break; case ClientType.Node: NodeDescriptor clientNode; if (!toNode.AcDomain.NodeHost.Nodes.TryGetNodeByPublicKey(cmdDto.Credential.ClientId, out clientNode)) { throw new GeneralException("意外的客户节点标识" + cmdDto.Credential.ClientId); } switch (credentialType) { case CredentialType.Undefined: break; case CredentialType.Token: cmdDto.Credential.Password = TokenObject.Token(cmdDto.Credential.ClientId, cmdDto.Credential.Ticks, clientNode.Node.SecretKey); break; case CredentialType.Signature: cmdDto.Credential.Password = Signature.Sign(cmdDto.ToOrignalString(cmdDto.Credential), clientNode.Node.SecretKey); break; case CredentialType.OAuth: break; default: break; } break; case ClientType.App: break; case ClientType.Monitor: break; default: break; } } return cmdDto.ToAnyCommand(toNode).Request(); }