public class OAuthBase
    {
        public static long CreateTimestamp()
        {
            var now = DateTime.UtcNow;
            var then = new DateTime( 1970 ,  1 ,  1 );
            var timespan = (now - then);
            var timestamp = (long)timespan.TotalSeconds;
            return timestamp;
        }

        private const string ALPHANUMERIC = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        public static string CreateNonce()
        {
            var sb = new StringBuilder();
            var random = new Random();
            for (var i =  0 ; i <=  12 ; i++)
            {
                var index = random.Next(ALPHANUMERIC.Length);
                sb.Append(ALPHANUMERIC[index]);
            }
            return sb.ToString();
        }

        public static string NormalizeUrl(string url)
        {
            Uri uri;
            // only work with a valid URL in lowercase
            if (Uri.TryCreate(url, UriKind.Absolute, out uri))
            {
                // only include non-standard ports
                string port = "";
                if (uri.Scheme.Equals("http") && uri.Port !=  80  ||
                   uri.Scheme.Equals("https") && uri.Port !=  443  ||
                   uri.Scheme.Equals("ftp") && uri.Port !=  20 )
                {
                    port = ":" + uri.Port;
                }
                // use only the scheme, host, port, and path
                url = uri.Scheme + "://" + uri.Host + port + uri.AbsolutePath;
            }
            return url;
        }

        public static string NormalizeRequestParameters(NameValueCollection parameters)
        {
            var sb = new StringBuilder();
            var list = new List<NameValuePair>();
            foreach (var name in parameters.AllKeys)
            {
                // escaping occurs both here, and during concatenation
                var value = Uri.EscapeDataString(parameters[name]);
                var item = new NameValuePair { Name = name, Value = value };

                // Ensure duplicates are not included
                if (list.Contains(item))
                {
                    throw new ArgumentException("Cannot add duplicate parameters");
                }
                list.Add(item);
            }
            list.Sort((left, right) =>
                {
                    if (left.Name.Equals(right.Name))
                    {
                        return left.Value.CompareTo(right.Value);
                    }
                    return left.Name.CompareTo(right.Name);
                });
            foreach (var item in list)
            {
                sb.Append(item.Name + "=" + item.Value);
                if (list.IndexOf(item) < list.Count -  1 )
                {
                    sb.Append("&");
                }
            }
            return sb.ToString();
        }

        private class NameValuePair
        {
            public string Name { get; set; }
            public string Value { get; set; }

            public bool Equals(NameValuePair other)
            {
                return Equals(other.Name, Name) &&
                       Equals(other.Value, Value);
            }

            public override bool Equals(object obj)
            {
                return Equals((NameValuePair)obj);
            }

            public override int GetHashCode()
            {
                return base.GetHashCode();
            }
        }

        public static string ConcatenateRequestElements(string method, string url, string parameters)
        {
            // URL encode base elements
            url = Uri.EscapeDataString(url);
            parameters = Uri.EscapeDataString(parameters);

            // build signature base according to spec
            var sb = new StringBuilder();
            sb.Append(method.ToUpper()).Append("&");
            sb.Append(url).Append("&");
            sb.Append(parameters);

            return sb.ToString();
        }

        public static string CreateSignature(string signatureBase, string consumerSecret, string tokenSecret)
        {
            if (tokenSecret == null)
            {
                // the token secret is unknown
                tokenSecret = string.Empty;
            }

            // URL encode key elements
            consumerSecret = Uri.EscapeDataString(consumerSecret);
            tokenSecret = Uri.EscapeDataString(tokenSecret);

            // initialize the cryptography provider
            var key = String.Concat(consumerSecret, "&", tokenSecret);
            var keyBytes = Encoding.ASCII.GetBytes(key);
            var signatureMethod = new HMACSHA1(keyBytes);

            // create a signature with the base and provider
            var data = Encoding.ASCII.GetBytes(signatureBase);
            var hash = signatureMethod.ComputeHash(data);
            var signature = Convert.ToBase64String(hash);

            // You must encode the URI for safe net travel
            signature = Uri.EscapeDataString(signature);
            return signature;
        }
    }

public enum Method { GET, POST };
        public string OAuthWebRequest(Method method, string url, string postData)
        {
            var timestamp = OAuthBase.CreateTimestamp().ToString(); // тут все ок, фомируется
            var nonce = OAuthBase.CreateNonce(); // аналогично
            var oauthParameters = new NameValueCollection
            {
                {"oauth_timestamp", timestamp},
                {"oauth_nonce", nonce},
                {"oauth_version", "1.0"},
                {"oauth_signature_method", "HMAC-SHA1"},
                {"oauth_consumer_key", ConsumerKey}
            };

            url = OAuthBase.NormalizeUrl(url);
            var parameters = OAuthBase.NormalizeRequestParameters(oauthParameters);
            var signatureBase = OAuthBase.ConcatenateRequestElements(method.ToString(), url, parameters);

            var signature = OAuthBase.CreateSignature(signatureBase, ConsumerSecret, TokenSecret); // разумеется сейчас TokenSecret = string.emty, но это так и должно быть.
            oauthParameters.Add("oauth_signature", signature);

            var header = new StringBuilder();
            header.Append("OAuth realm=\"\", ");
            for (var i =  0 ; i < oauthParameters.Count; i++)
            {
                var key = oauthParameters.GetKey(i);
                var pair = key + "=\"" + oauthParameters[key] + "\"";
                header.Append(pair);
                if (i < oauthParameters.Count -  1 )
                {
                    header.Append(", ");
                }
            }

            System.Net.ServicePointManager.Expect100Continue = false;
            var request = (HttpWebRequest)WebRequest.Create(url); // просто перенаправил вбитый url
            request.Headers["Authorization"] = header.ToString(); // ну вроде бы, с виду, все идеально
            request.Method = method.ToString();
            if (method == Method.POST) // можно не рассматривать, мы шлем GET запрос
            {
                request.ContentType = "application/x-www-form-urlencoded";
                StreamWriter requestWriter = new StreamWriter(request.GetRequestStream());
                try { requestWriter.Write(postData); }
                catch { throw; }
                finally
                {
                    requestWriter.Close();
                    requestWriter = null;
                }
            }

            WebResponse response = request.GetResponse();
            /* тут забираем нашу ошибку:
                   Удаленный сервер возвратил ошибку: (401) Несанкционированный.
                   В дополнение возвращает - Failed to validate oauth signature and token
            */
            StreamReader responseReader = new StreamReader(response.GetResponseStream());
            var responseData = responseReader.ReadToEnd();
            response.Close();
            responseReader.Close();
            responseReader = null;
            request = null;
            return responseData;
        }

        public void SignIn()
        {
           string response = OAuthWebRequest(Method.GET, "http://twitter.com/oauth/request_token", string.Empty);
}