public StringBuilder GetSkipToken() { object[] skipTokenProperties = this.GetSkipTokenProperties(); bool flag = true; for (int i = 0; i < skipTokenProperties.Length; i++) { string str; object obj2 = skipTokenProperties[i]; if (obj2 == null) { str = "null"; } else if (!WebConvert.TryKeyPrimitiveToString(obj2, out str)) { throw new InvalidOperationException(System.Data.Services.Strings.Serializer_CannotConvertValue(obj2)); } if (!flag) { this.skipToken.Append(','); } this.skipToken.Append(str); flag = false; } return(this.skipToken); }
internal static bool TryKeyPrimitiveToString(object value, out string result) { if (IsBinaryValue(value)) { return(TryKeyBinaryToString(value, out result)); } return(WebConvert.TryKeyPrimitiveToString(value, out result)); }
private static IEnumerable <KeyValuePair <string, object> > ParseETagValue(IList <ResourceProperty> etagProperties, string ifMatchHeaderValue) { bool flag; if (ifMatchHeaderValue == "*") { return(WebUtil.EmptyKeyValuePairStringObject); } string stringToUnescape = ifMatchHeaderValue.Substring("W/\"".Length, (ifMatchHeaderValue.Length - "W/\"".Length) - 1); KeyInstance instance = null; Exception innerException = null; try { flag = KeyInstance.TryParseNullableTokens(Uri.UnescapeDataString(stringToUnescape), out instance); } catch (DataServiceException exception2) { flag = false; innerException = exception2; } if (!flag) { throw DataServiceException.CreatePreConditionFailedError(System.Data.Services.Strings.Serializer_ETagValueDoesNotMatch, innerException); } if (instance.PositionalValues.Count != etagProperties.Count) { throw DataServiceException.CreatePreConditionFailedError(System.Data.Services.Strings.Serializer_ETagValueDoesNotMatch); } KeyValuePair <string, object>[] pairArray = new KeyValuePair <string, object> [etagProperties.Count]; for (int i = 0; i < pairArray.Length; i++) { ResourceProperty property = etagProperties[i]; object targetValue = null; string text = (string)instance.PositionalValues[i]; if (text != "null") { try { flag = WebConvert.TryKeyStringToPrimitive(text, property.Type, out targetValue); } catch (OverflowException exception3) { flag = false; innerException = exception3; } if (!flag) { throw DataServiceException.CreatePreConditionFailedError(System.Data.Services.Strings.Serializer_ETagValueDoesNotMatch, innerException); } } pairArray[i] = new KeyValuePair <string, object>(etagProperties[i].Name, targetValue); } return(pairArray); }
/// <summary>Tries to convert values to the keys of the specified type.</summary> /// <param name="type">Type with key information for conversion.</param> /// <returns>true if all values were converted; false otherwise.</returns> internal bool TryConvertValues(ResourceType type) { Debug.Assert(type != null, "type != null"); Debug.Assert(!this.IsEmpty, "!this.IsEmpty -- caller should check"); Debug.Assert(type.KeyProperties.Count == this.ValueCount, "type.KeyProperties.Count == this.ValueCount -- will change with containment"); if (this.namedValues != null) { for (int i = 0; i < type.KeyProperties.Count; i++) { ResourceProperty property = type.KeyProperties[i]; object unconvertedValue; if (!this.namedValues.TryGetValue(property.Name, out unconvertedValue)) { return(false); } string valueText = (string)unconvertedValue; object convertedValue; if (!WebConvert.TryKeyStringToPrimitive(valueText, property.Type, out convertedValue)) { return(false); } this.namedValues[property.Name] = convertedValue; } } else { Debug.Assert(this.positionalValues != null, "positionalValues != null -- otherwise this is Empty"); for (int i = 0; i < type.KeyProperties.Count; i++) { string valueText = (string)this.positionalValues[i]; object convertedValue; if (!WebConvert.TryKeyStringToPrimitive(valueText, type.KeyProperties[i].Type, out convertedValue)) { return(false); } this.positionalValues[i] = convertedValue; } } return(true); }
/// <summary> /// Tries to extract the WellKnownTextSQL portion from an astoria spatial literal. /// </summary> /// <param name="spatialLiteral">The spatial literal.</param> /// <param name="prefix">The prefix.</param> /// <param name="wellKnownTextSql">The well known text SQL.</param> /// <returns>true if the extract was successful, false otherwise.</returns> private static bool TryExtractWellKnownTextSqlFromSpatialLiteral(string spatialLiteral, string prefix, out string wellKnownTextSql) { var worked = WebConvert.TryRemovePrefix(prefix, ref spatialLiteral); if (!worked) { wellKnownTextSql = null; return(false); } worked = WebConvert.TryRemoveQuotes(ref spatialLiteral); if (!worked) { wellKnownTextSql = null; return(false); } wellKnownTextSql = spatialLiteral; return(true); }
/// <summary> /// Converts the given value to the expected type as per XML serializer rules. /// Make sure these rules are in sync with PlainXmlSerializer. /// </summary> /// <param name="value">value to the converted</param> /// <param name="propertyName">name of the property whose value is getting converted</param> /// <param name="typeToBeConverted">clr type to which the value needs to be converted to</param> /// <returns>object which is in sync with the properties type</returns> internal static object ConvertValuesForXml(object value, string propertyName, Type typeToBeConverted) { Debug.Assert(WebUtil.IsPrimitiveType(typeToBeConverted), "WebUtil.IsPrimitiveType(typeToBeConverted)"); Debug.Assert(value == null || value is string, "This method should be used only for converting string to a primitve value."); string stringValue = value as string; if (stringValue != null) { try { value = WebConvert.StringToPrimitive(stringValue, typeToBeConverted); } catch (FormatException e) { throw DataServiceException.CreateBadRequestError(Strings.BadRequest_ErrorInConvertingPropertyValue(propertyName, typeToBeConverted), e); } } return(value); }
private static string GetObjectKey(object resource, ResourceType resourceType, DataServiceProviderWrapper provider, string containerName) { StringBuilder builder = new StringBuilder(); builder.Append(containerName); builder.Append('('); IList <ResourceProperty> keyProperties = resourceType.KeyProperties; for (int i = 0; i < keyProperties.Count; i++) { string str; ResourceProperty resourceProperty = keyProperties[i]; object obj2 = WebUtil.GetPropertyValue(provider, resource, resourceType, resourceProperty, null); if (obj2 == null) { throw new InvalidOperationException(System.Data.Services.Strings.Serializer_NullKeysAreNotSupported(resourceProperty.Name)); } if (i == 0) { if (keyProperties.Count != 1) { builder.Append(resourceProperty.Name); builder.Append('='); } } else { builder.Append(','); builder.Append(resourceProperty.Name); builder.Append('='); } if (!WebConvert.TryKeyPrimitiveToString(obj2, out str)) { throw new InvalidOperationException(System.Data.Services.Strings.Serializer_CannotConvertValue(obj2)); } builder.Append(str); } builder.Append(')'); return(builder.ToString()); }
internal static string GetETagValue(object resource, ResourceType resourceType, ICollection <ResourceProperty> etagProperties, IDataService service, bool getMethod) { StringBuilder builder = new StringBuilder(); bool flag = true; builder.Append("W/\""); foreach (ResourceProperty property in etagProperties) { object obj2; string str; if (getMethod) { obj2 = GetPropertyValue(service.Provider, resource, resourceType, property, null); } else { obj2 = service.Updatable.GetValue(resource, property.Name); } if (flag) { flag = false; } else { builder.Append(','); } if (obj2 == null) { str = "null"; } else if (!WebConvert.TryKeyPrimitiveToString(obj2, out str)) { throw new InvalidOperationException(System.Data.Services.Strings.Serializer_CannotConvertValue(obj2)); } builder.Append(str); } builder.Append('"'); return(builder.ToString()); }
internal bool TryConvertValues(ResourceType type) { if (this.namedValues != null) { for (int i = 0; i < type.KeyProperties.Count; i++) { object obj2; object obj3; ResourceProperty property = type.KeyProperties[i]; if (!this.namedValues.TryGetValue(property.Name, out obj2)) { return(false); } string text = (string)obj2; if (!WebConvert.TryKeyStringToPrimitive(text, property.Type, out obj3)) { return(false); } this.namedValues[property.Name] = obj3; } } else { for (int j = 0; j < type.KeyProperties.Count; j++) { object obj4; string str2 = (string)this.positionalValues[j]; if (!WebConvert.TryKeyStringToPrimitive(str2, type.KeyProperties[j].Type, out obj4)) { return(false); } this.positionalValues[j] = obj4; } } return(true); }
/// <summary>Parses a token that starts with a digit.</summary> /// <returns>The kind of token recognized.</returns> private ExpressionTokenKind ParseFromDigit() { Debug.Assert(this.IsValidDigit || ('-' == this.ch), "this.IsValidDigit || ('-' == this.ch)"); ExpressionTokenKind result; int tokenPos = this.textPos; char?startChar = this.ch; this.NextChar(); if (startChar == '0' && (this.ch == 'x' || this.ch == 'X')) { result = ExpressionTokenKind.BinaryLiteral; do { this.NextChar(); }while (this.ch.HasValue && WebConvert.IsCharHexDigit(this.ch.Value)); } else { result = ExpressionTokenKind.IntegerLiteral; while (this.IsValidDigit) { this.NextChar(); } // DateTimeOffset and Guids will have '-' in them if (this.ch == '-') { if (this.TryParseDateTimeoffset(tokenPos)) { return(ExpressionTokenKind.DateTimeOffsetLiteral); } else if (this.TryParseGuid(tokenPos)) { return(ExpressionTokenKind.GuidLiteral); } } // Guids will have alpha-numeric characters along with '-', so if a letter is encountered // try to see if this is Guid or not. if (this.ch.HasValue && Char.IsLetter(this.ch.Value)) { if (this.TryParseGuid(tokenPos)) { return(ExpressionTokenKind.GuidLiteral); } } if (this.ch == '.') { result = ExpressionTokenKind.DoubleLiteral; this.NextChar(); this.ValidateDigit(); do { this.NextChar(); }while (this.IsValidDigit); } if (this.ch == 'E' || this.ch == 'e') { result = ExpressionTokenKind.DoubleLiteral; this.NextChar(); if (this.ch == '+' || this.ch == '-') { this.NextChar(); } this.ValidateDigit(); do { this.NextChar(); }while (this.IsValidDigit); } if (this.ch == 'M' || this.ch == 'm') { result = ExpressionTokenKind.DecimalLiteral; this.NextChar(); } else if (this.ch == 'd' || this.ch == 'D') { result = ExpressionTokenKind.DoubleLiteral; this.NextChar(); } else if (this.ch == 'L' || this.ch == 'l') { result = ExpressionTokenKind.Int64Literal; this.NextChar(); } else if (this.ch == 'f' || this.ch == 'F') { result = ExpressionTokenKind.SingleLiteral; this.NextChar(); } else { string valueStr = this.text.Substring(tokenPos, this.textPos - tokenPos); result = MakeBestGuessOnNoSuffixStr(valueStr, result); } } return(result); }
internal static bool TryKeyBinaryToString(object binaryValue, out string result) { byte[] buffer = (byte[])binaryValue.GetType().InvokeMember("ToArray", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, binaryValue, null, CultureInfo.InvariantCulture); return(WebConvert.TryKeyPrimitiveToString(buffer, out result)); }
private static bool QuotesAreValid(string text) { return(WebConvert.TryRemoveQuotes(ref text)); }
// Get the access token via straight http post request doing client credential flow private async Task <String> GetAppOnlyAccessTokenWithHttpRequest(string resource, string tenantId) { /** * use the tenant specific endpoint for requesting the app-only access token */ string tokenIssueEndpoint = appConfig.TokenIssueingUri.Replace("common", tenantId); /** * sign the assertion with the private key */ string certfile = Server.MapPath(appConfig.ClientCertificatePfx); X509Certificate2 cert = new X509Certificate2( certfile, appConfig.ClientCertificatePfxPassword, X509KeyStorageFlags.MachineKeySet); /** * Example building assertion using Json Tokenhandler. * Sort of cheating, but just if someone wonders ... there are always more ways to do something :-) */ Dictionary <string, string> claims = new Dictionary <string, string>() { { "sub", appConfig.ClientId }, { "jti", Guid.NewGuid().ToString() }, }; JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler(); X509SigningCredentials signingCredentials = new X509SigningCredentials(cert, SecurityAlgorithms.RsaSha256Signature, SecurityAlgorithms.Sha256Digest); JwtSecurityToken selfSignedToken = new JwtSecurityToken( appConfig.ClientId, tokenIssueEndpoint, claims.Select(c => new Claim(c.Key, c.Value)), DateTime.UtcNow, DateTime.UtcNow.Add(TimeSpan.FromMinutes(15)), signingCredentials); string signedAssertion = tokenHandler.WriteToken(selfSignedToken); //---- End example with Json Tokenhandler... now to the fun part doing it all ourselves ... /** * Example building assertion from scratch with Crypto APIs */ JObject clientAssertion = new JObject(); clientAssertion.Add("aud", tokenIssueEndpoint); clientAssertion.Add("iss", appConfig.ClientId); clientAssertion.Add("sub", appConfig.ClientId); clientAssertion.Add("jti", Guid.NewGuid().ToString()); clientAssertion.Add("nbf", WebConvert.EpocTime(DateTime.UtcNow + TimeSpan.FromMinutes(-5))); clientAssertion.Add("exp", WebConvert.EpocTime(DateTime.UtcNow + TimeSpan.FromMinutes(15))); string assertionPayload = clientAssertion.ToString(Newtonsoft.Json.Formatting.None); X509AsymmetricSecurityKey x509Key = new X509AsymmetricSecurityKey(cert); RSACryptoServiceProvider rsa = x509Key.GetAsymmetricAlgorithm(SecurityAlgorithms.RsaSha256Signature, true) as RSACryptoServiceProvider; RSACryptoServiceProvider newRsa = GetCryptoProviderForSha256(rsa); SHA256Cng sha = new SHA256Cng(); JObject header = new JObject(new JProperty("alg", "RS256")); string thumbprint = WebConvert.Base64UrlEncoded(WebConvert.HexStringToBytes(cert.Thumbprint)); header.Add(new JProperty("x5t", thumbprint)); string encodedHeader = WebConvert.Base64UrlEncoded(header.ToString()); string encodedPayload = WebConvert.Base64UrlEncoded(assertionPayload); string signingInput = String.Concat(encodedHeader, ".", encodedPayload); byte[] signature = newRsa.SignData(Encoding.UTF8.GetBytes(signingInput), sha); signedAssertion = string.Format("{0}.{1}.{2}", encodedHeader, encodedPayload, WebConvert.Base64UrlEncoded(signature)); /** * build the request payload */ FormUrlEncodedContent tokenRequestForm; tokenRequestForm = new FormUrlEncodedContent( new[] { new KeyValuePair <string, string>("resource", appConfig.ExchangeResourceUri), new KeyValuePair <string, string>("client_id", appConfig.ClientId), new KeyValuePair <string, string>("client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer"), new KeyValuePair <string, string>("client_assertion", signedAssertion), new KeyValuePair <string, string>("grant_type", "client_credentials"), } ); /* * Do the web request */ HttpClient client = new HttpClient(); Task <string> requestString = tokenRequestForm.ReadAsStringAsync(); StringContent requestContent = new StringContent(requestString.Result); requestContent.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded"); requestContent.Headers.Add("client-request-id", System.Guid.NewGuid().ToString()); requestContent.Headers.Add("return-client-request-id", "true"); requestContent.Headers.Add("UserAgent", "MatthiasLeibmannsAppOnlyAppSampleBeta/0.1"); HttpResponseMessage response = client.PostAsync(tokenIssueEndpoint, requestContent).Result; JObject jsonResponse = JObject.Parse(response.Content.ReadAsStringAsync().Result); JsonSerializer jsonSerializer = new JsonSerializer(); if (response.IsSuccessStatusCode == true) { AADClientCredentialSuccessResponse s = (AADClientCredentialSuccessResponse)jsonSerializer.Deserialize(new JTokenReader(jsonResponse), typeof(AADClientCredentialSuccessResponse)); return(s.access_token); } AADClientCredentialErrorResponse e = (AADClientCredentialErrorResponse)jsonSerializer.Deserialize(new JTokenReader(jsonResponse), typeof(AADClientCredentialErrorResponse)); throw new Exception(e.error_description); }
private Expression PromoteExpression(Expression expr, Type type, bool exact, bool isTypeCast = false) { Debug.Assert(expr != null, "expr != null"); Debug.Assert(type != null, "type != null"); if (expr.Type == type) { return(expr); } ConstantExpression ce = null; if (type == typeof(DateTime)) { // Sometimes if the property type is DateTime? in provider, we pass the type as DateTimeOffset? // to ODataLib and it puts a Convert node to convert DateTimeOffset to DateTimeOffset?. Hence // to reach to the constant value, we need to handle the Convert node. if (expr.Type == typeof(DateTimeOffset) || expr.Type == typeof(DateTimeOffset?)) { if (expr.NodeType == ExpressionType.Convert) { ce = ((UnaryExpression)expr).Operand as ConstantExpression; } } } if (ce == null) { ce = expr as ConstantExpression; } if (ce != null) { if (ce == ExpressionUtils.NullLiteral) { if (WebUtil.TypeAllowsNull(type)) { return(Expression.Constant(null, type)); } } else { string text; if (this.literals.TryGetValue(ce, out text)) { Type target = WebUtil.GetNonNullableType(type); object value = null; if (ce.Type == typeof(string) && (target == typeof(Type) || target == typeof(ResourceType))) { // No qoutes required when the function is a cast if (isTypeCast || WebConvert.TryRemoveQuotes(ref text)) { ResourceType resourceType = this.tryResolveResourceType(text); if (resourceType != null) { if (target == typeof(Type)) { if (resourceType.CanReflectOnInstanceType) { value = resourceType.InstanceType; } } else { if (resourceType.CanReflectOnInstanceType == false) { value = resourceType; } } } } } else if ((type == typeof(DateTime) || type == typeof(DateTime?)) && (expr.Type == typeof(DateTimeOffset) || expr.Type == typeof(DateTimeOffset?))) { // Since the URI parser in ODataLib will always convert Constants as DateTimeOffset, // and WCF DS Server supports DateTime clr type, we need to do the conversion whenever required. value = WebUtil.ConvertDateTimeOffsetToDateTime((DateTimeOffset)ce.Value); } else { switch (Type.GetTypeCode(ce.Type)) { case TypeCode.Int32: case TypeCode.Int64: value = ParseNumber(text, target); break; case TypeCode.Double: if (target == typeof(decimal)) { value = ParseNumber(text, target); } break; } } if (value != null) { return(Expression.Constant(value, type)); } } } } if (IsCompatibleWith(expr.Type, type)) { // (type != typeof(object) || expr.Type.IsValueType) part is added // to prevent cast to System.Object from non-value types (objects). if (type.IsValueType || exact && (type != typeof(object) || expr.Type.IsValueType)) { return(Expression.Convert(expr, type)); } return(expr); } // Allow promotion from nullable to non-nullable by directly accessing underlying value. if (WebUtil.IsNullableType(expr.Type) && type.IsValueType) { Expression valueAccessExpression = Expression.Property(expr, "Value"); valueAccessExpression = this.PromoteExpression(valueAccessExpression, type, exact, isTypeCast); return(valueAccessExpression); } return(null); }