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();
}
