Exemple #1
0
        private static string ExtractAuthHeader(System.Net.Http.Headers.HttpRequestHeaders headers, string headerName)
        {
            string result = String.Empty;

            try
            {
                //Check header
                result = String.IsNullOrEmpty(headers.GetValues(headerName).FirstOrDefault()) ? String.Empty : headers.GetValues(headerName).FirstOrDefault();
            }
            catch (Exception)
            {
                //Nothing, the header was not found
            }
            if (String.IsNullOrEmpty(result))
            {
                try
                {
                    //Check Cookie
                    var cookieAuth = GetCookie(headers, headerName);
                    if (cookieAuth != null)
                    {
                        result = cookieAuth;
                    }
                }
                catch
                {
                    // fallback here because it is null
                }
            }
            return(result);
        }
 public static string GetCookie(HttpRequestHeaders headers, string name)
 {
     var cookies = headers.GetCookies(name).FirstOrDefault();
     if (cookies == null) return null;
     var cookie = cookies.Cookies.SingleOrDefault(x => x.Name == name);
     return cookie == null ? null : cookie.Value;
 }
        public void SetUp()
        {
            var request = new HttpRequestMessage();
            theHeaders = request.Headers;

            theKeyValues = new HeaderKeyValues(theHeaders);
        }
 internal static void CopyTo(this HttpRequestHeaders from, HttpRequestHeaders to)
 {
     foreach (var header in from)
     {
         to.TryAddWithoutValidation(header.Key, header.Value);
     }
 }
 internal void Populate(HttpRequestHeaders headers)
 {
     if (this.CacheControl != null)
     {
         headers.Add("response-cache-control", this.CacheControl);
     }
     if (this.ContentDisposition != null)
     {
         headers.Add("response-content-disposition", this.ContentDisposition);
     }
     if (this.ContentEncoding != null)
     {
         headers.Add("response-content-encoding", this.ContentEncoding);
     }
     if (this.ContentLanguage != null)
     {
         headers.Add("response-content-language", this.ContentLanguage);
     }
     if (this.ContentType != null)
     {
         headers.Add("response-content-type", this.ContentType);
     }
     if (this.Expires != null)
     {
         headers.Add("response-expires", this.Expires);
     }
 }
        public static ApiCredentials GetFromRequestHeaders(HttpRequestHeaders requestHeaders)
        {
            //this could/should be another interface for testing purposes
            var authenticationHeader = requestHeaders.Authorization;
            if (authenticationHeader.Scheme != Configuration.AuthenticationScheme)
            {
                return null;
            }
            if (requestHeaders.Authorization == null || requestHeaders.Authorization.Parameter == null
                || !requestHeaders.Authorization.Parameter.Contains(":"))
            {
                return null;
            }

            var apiKey = requestHeaders.Authorization.Parameter.Split(':')[0]; 
            if (apiKey == null)
            {
                return null;
            }

            var decodedBytes = Convert.FromBase64String(authenticationHeader.Parameter);
            var signature = Encoding.UTF8.GetString(decodedBytes);
            return new ApiCredentials()
            {
                Signature = signature,
                ApiKey = apiKey
            };
        }
        internal static string CanonicalizedHeaders(HttpRequestHeaders headers)
        {
            var canonicalizedString = new CanonicalizedString(string.Empty);

            var keyList =
                headers.Where(h => h.Key.StartsWith("x-ms-", StringComparison.OrdinalIgnoreCase)).Select(header => header.Key).ToList();

            keyList.Sort();
            foreach (string str2 in keyList)
            {
                var builder = new StringBuilder(str2);
                string str3 = ":";
                foreach (string str4 in GetHeaderValues(headers, str2))
                {
                    string str5 = str4.Replace("\r\n", string.Empty);
                    builder.Append(str3);
                    builder.Append(str5);
                    str3 = ",";
                }

                canonicalizedString.AppendCanonicalizedElement(builder.ToString());
            }

            return canonicalizedString.Value.TrimEnd('\n').TrimStart('\n');
        }
 private string _GetCanonicalizedHeaders(HttpRequestHeaders headers)
 {
     var orderedHeaders = headers.OrderBy(x => x.Key);
     var headersWithAggregatedValues = orderedHeaders.Where(x => x.Key.StartsWith("x-ms")).Select(x => x.Key.ToLowerInvariant() + ":" + headers.GetValues(x.Key).Aggregate((x1, x2) => x1 + "," + x2));
     var canonicalHeader = headersWithAggregatedValues.Aggregate((x1, x2) => x1 + "\n" + x2) + "\n";
     return canonicalHeader;
 }
Exemple #9
0
        /// <summary>
        /// Authorization request header from client.
        /// </summary>
        /// <param name="header">header from client</param>
        /// <returns>-401/-403/{userId}</returns>
        public static long Authentication(HttpRequestHeaders header)
        {
            string authorization = header.GetValues("Authorization").FirstOrDefault();
            if (authorization == null)
                {
                    return -401;
                }
            using (var db = new CF_FamsamEntities())
            {
                string token = authorization.Split(null)[1];
                    Session session = db.Session.Find(token);
                    Debug.WriteLine("____________________________" + session.token);
                    if (session == null) return -403;

                    if (session.expired < DateTime.Now)
                    {
                        Debug.WriteLine("____________________________ session mili:" + session.expired.Millisecond);
                        Debug.WriteLine("____________________________ now mili:" + DateTime.Now.Millisecond);
                        //session expired
                        db.Session.Remove(session);
                        db.SaveChanges();
                        return -403;
                    }
                    else
                    {
                        return session.User.id;
                    }


                

            }
        }
        private async Task<ClaimsPrincipal> BuildClaimsPrincipal(HttpRequestHeaders headers)
        {
            string credentials;
            try
            {
                var token = Convert.FromBase64String(headers.Authorization.Parameter);
                credentials = Encoding.UTF8.GetString(token);
            }
            catch (FormatException)
            {
                return null;
            }
            catch (ArgumentException)
            {
                return null;
            }

            var parts = credentials.Split(':');

            if (parts.Length != 2)
                return null;

            var userId = parts[0].Trim();
            var password = parts[1].Trim();

            if (! await _validateCredentials(userId, password))
                return null;

            var claims = new[] {new Claim(ClaimTypes.Name, userId)};
            var claimsIdentities = new[] {new ClaimsIdentity(claims, Scheme)};
            return new ClaimsPrincipal(claimsIdentities);
        }
 internal void Populate(HttpRequestHeaders headers)
 {
     if (this.Range != null)
     {
         headers.Range = new RangeHeaderValue(this.Range[0], this.Range[1]);
     }
     if (this.ModifiedSinceConstraint.HasValue)
     {
         headers.IfModifiedSince = new DateTimeOffset(this.ModifiedSinceConstraint.Value);
     }
     if (this.UnmodifiedSinceConstraint.HasValue)
     {
         headers.IfUnmodifiedSince = new DateTimeOffset(this.UnmodifiedSinceConstraint.Value);
     }
     if (this._matchingETagConstraints.Count > 0)
     {               
         foreach (string temp in this._matchingETagConstraints)
             headers.IfMatch.Add(new EntityTagHeaderValue(temp));
     }
     if (this._nonmatchingEtagConstraints.Count > 0)
     {
         foreach (string temp in this._nonmatchingEtagConstraints)
             headers.IfMatch.Add(new EntityTagHeaderValue(temp));
     }
 }
		/// <summary>
		/// Initializes a new instance of the <see cref="HttpRequestMessage" /> class
		/// with an HTTP method and a request System.Uri.
		/// </summary>
		/// <param name="method">The HTTP method.</param>
		/// <param name="requestUri">The System.Uri to request.</param>
		public HttpRequestMessage(HttpMethod method, Uri requestUri)
		{
			RequestUri = requestUri;
			Properties = new Dictionary<string, object>();
			Version = new Version("1.1");
			Method = method;
			Headers = new HttpRequestHeaders(new WebHeaderCollection());
		}
 public string Build(string verb, string content, StorageUri uri, AzureStorageAccountInfo accountInfo, HttpRequestHeaders headers, string contentType)
 {
     var ifMatch = "";
     var md5 = "";
     var canonicalizedHeaderString = _GetCanonicalizedHeaders(headers);
     var canonResource = _GetCanonicalizedResource(new Uri(uri.ToUriString()), accountInfo.Account);
     var authorizationHeader = _GetAuthorizationHeader(verb, content, ifMatch, canonicalizedHeaderString, canonResource, md5, accountInfo, contentType);
     return authorizationHeader;
 }
Exemple #14
0
 public static bool AuthenticateUser(HttpRequestHeaders HttpHeaders)
 {
     if (HttpHeaders.Contains(HttpRequestHeaderName))
     {
         var authHeader = HttpHeaders.GetValues(HttpRequestHeaderName).First();
         return _authenticateHeaderValue(authHeader);
     }
     return false;
 }
        public static bool IsHeaderContainToken(HttpRequestHeaders header)
        {
            if (header.Contains(Constants.AccessTokenKey))
            {
                return true;
            }

            return false;
        }
        public string GetValueStorage(HttpRequestHeaders context, string key)
        {
            
            var cookie = context.GetCookies(key).FirstOrDefault();
            if (cookie != null)
                return cookie[key].Value;

            return null;
        }
 protected bool ReadAuthenticationContent(HttpRequestHeaders authenticationContent, string key, out string value)
 {
     value = string.Empty;
     var content = authenticationContent.FirstOrDefault(pair => pair.Key == key);
     if (content.Value == null || content.Value.Count() != 1)
         return false;
     value = content.Value.First();
     return true;
 }
        /// <summary>
        /// Canonicalizes the HTTP headers.
        /// </summary>
        /// <param name="method">The HTTP method for the request.</param>
        /// <param name="requestHeaders">The request headers.</param>
        /// <param name="contentHeaders">The content headers.</param>
        /// <returns>A string representation of the HTTP headers.</returns>
        private static string CanonicalizeHttpHeaders(
            HttpMethod method,
            HttpRequestHeaders requestHeaders,
            HttpContentHeaders contentHeaders)
        {
            long? contentLength = contentHeaders != null ? contentHeaders.ContentLength : null;

            return CanonicalizeHttpHeaders(method, contentLength, requestHeaders, contentHeaders);
        }
        private static string GetCookieValue(IAbpAntiForgeryManager manager, HttpRequestHeaders headers)
        {
            var cookie = headers.GetCookies(manager.Configuration.TokenCookieName).LastOrDefault();
            if (cookie == null)
            {
                return null;
            }

            return cookie[manager.Configuration.TokenCookieName].Value;
        }
        public static void CopyTo(this HttpRequestHeaders fromHeaders, HttpRequestHeaders toHeaders)
        {
            Contract.Assert(fromHeaders != null, "fromHeaders cannot be null.");
            Contract.Assert(toHeaders != null, "toHeaders cannot be null.");

            foreach (KeyValuePair<string, IEnumerable<string>> header in fromHeaders)
            {
                toHeaders.TryAddWithoutValidation(header.Key, header.Value);
            }
        }
Exemple #21
0
        public static string GetHeaderValue(HttpRequestHeaders headers, string key)
        {
            IEnumerable<string> values;

            if (headers.TryGetValues(key, out values))
            {
                return values.FirstOrDefault();
            }

            return null;
        }
        private static IEnumerable<string> GetHeaderValues(HttpRequestHeaders headers, string headerName)
        {
            var header = headers.Where(
                fx => fx.Key.Equals(headerName, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
            if ( header.Key != null && header.Value != null )
            {
                return header.Value;
            }

            return new List<string>();
        }
        private static string GetHeaderValue(HttpRequestHeaders headers, string headerName)
        {
            var values = GetHeaderValues(headers, headerName);
            if (values.Any())
            {
                // TODO: Test this to make sure it works in all cases, like null value of header key that exists
                return values.Take(1).FirstOrDefault();
            }

            return string.Empty;
        }
Exemple #24
0
        public static UserDataPrincipal InitFromAuthCookie(HttpRequestHeaders headers)
        {
            string authCookieName = FormsAuthentication.FormsCookieName;

            var cookieValues = headers.GetCookies(authCookieName);
            CookieHeaderValue authCookieValue = cookieValues.FirstOrDefault();
            if (authCookieValue == null)
                return null;

            CookieState authCookie = authCookieValue[authCookieName];
            return DecryptAuthTicket(authCookie.Value);
        }
        private void PopulateHeaders(HttpRequestHeaders httpRequestHeaders)
        {
            if (httpRequestHeaders.CacheControl != null)
                Headers.Add(new KeyValuePair("Cache-Control", httpRequestHeaders.CacheControl.ToString()));

            Headers.Add(new KeyValuePair("Connection", httpRequestHeaders.Connection.ToString()));
            Headers.Add(new KeyValuePair("Accept-Charset", httpRequestHeaders.AcceptCharset.ToString()));
            Headers.Add(new KeyValuePair("Accept-Encoding", httpRequestHeaders.AcceptEncoding.ToString()));
            Headers.Add(new KeyValuePair("Accept-Language", httpRequestHeaders.AcceptLanguage.ToString()));
            Headers.Add(new KeyValuePair("Host", httpRequestHeaders.Host.ToString()));
            Headers.Add(new KeyValuePair("User-Agent", httpRequestHeaders.UserAgent.ToString()));
        }
Exemple #26
0
        /// <summary>
        ///     Resets the headers to make any request to the Nexon Api look legit
        /// </summary>
        /// <param name="headers">The <see cref="HttpRequestHeaderCollection" /> that gets modified</param>
        private static void SetHeaders(HttpRequestHeaders headers)
        {
            headers.Clear();

            headers.Accept.ParseAdd("application/json, text/javascript, */*; q=0.01");
            headers.AcceptEncoding.ParseAdd("gzip,deflate");
            headers.AcceptLanguage.ParseAdd("en-GB,en-us;q=0.8,en;q=0.6");
            headers.UserAgent.ParseAdd(GetUserAgent);
            headers.Connection.TryParseAdd("keep-alive");
            headers.Host = new Uri(LoginUrl).Host;
            headers.Add("X-Requested-With", "XMLHttpRequest");
        }
        public ActionRequestEntry(
            HttpActionContext actionContext)
        {
            _controller = actionContext.ControllerContext.ControllerDescriptor.ControllerName;
            _action = actionContext.ActionDescriptor.ActionName;
            _arguments = actionContext.ActionArguments;

            _requestUri = actionContext.Request.RequestUri;
            _requestMethod = actionContext.Request.Method.Method;
            _requestHeaders = actionContext.Request.Headers;

            _clientIP = actionContext.Request.GetClientIpAddress();
        }
 private static IEnumerable<CookieHeaderValue> GetCookies(HttpRequestHeaders header)
 {
     var result = new System.Collections.ObjectModel.Collection<CookieHeaderValue>();
     IEnumerable<string> cookies;
     if (header.TryGetValues("Cookie", out cookies))
     {
         foreach (string cookie in cookies)
         {
             CookieHeaderValue cookieHeaderValue;
             if (CookieHeaderValue.TryParse(cookie, out cookieHeaderValue))
                 result.Add(cookieHeaderValue);
         }
     }
     return result;
 }
        public static bool IsValid(this IAbpAntiForgeryManager manager, HttpRequestHeaders headers)
        {
            var cookieTokenValue = GetCookieValue(manager, headers);
            if (cookieTokenValue.IsNullOrEmpty())
            {
                return true;
            }

            var headerTokenValue = GetHeaderValue(manager, headers);
            if (headerTokenValue.IsNullOrEmpty())
            {
                return false;
            }

            return manager.As<IAbpAntiForgeryValidator>().IsValid(cookieTokenValue, headerTokenValue);
        }
        private static string GetHeaderValue(IAbpAntiForgeryManager manager, HttpRequestHeaders headers)
        {
            IEnumerable<string> headerValues;
            if (!headers.TryGetValues(manager.Configuration.TokenHeaderName, out headerValues))
            {
                return null;
            }

            var headersArray = headerValues.ToArray();
            if (!headersArray.Any())
            {
                return null;
            }
            
            return headersArray.Last().Split(", ").Last();
        }
Exemple #31
0
        public static bool ExtractHeader(
            HttpRequestHeaders headers, string headerName, out string headerValue)
        {
            var token = headers.FirstOrDefault(x => x.Key == headerName);
            if (token.Key != null)
            {
                var firstToken = token.Value.FirstOrDefault();
                if (firstToken != null)
                {
                    headerValue = firstToken;
                    return true;
                };
            }

            headerValue = string.Empty;
            return false;
        }
        public T GetResult <T>(PublicApiCall call, string requestData)
            where T : IResponse, new()
        {
            var s = string.Format("{0}/Api/{1}{2}", BaseUrl, call, requestData);

            System.Net.Http.Headers.HttpRequestHeaders h = _client.DefaultRequestHeaders;

            var response = _client.GetStringAsync(s);

            if (string.IsNullOrEmpty(response.Result))
            {
                return(new T()
                {
                    Success = false, Error = "No Response."
                });
            }
            return(GetObject <T>(response.Result));
        }
 public static IEnumerable <KeyValuePair <string, string> > ParseToSingleValueKeyValuePairs(this HttpRequestHeaders headers)
 {
     return(headers.Select(x =>
                           new KeyValuePair <string, string>(
                               x.Key, x.Value.FirstOrDefault())));
 }