title: Twitter Streaming API and Oauth for pulling hashtag
body: <p>I am trying to get Oauth to work with the Twitter Streaming API but I am getting a 401 Unauthorized error.  I found a blog that provided code for the Oauth authentication, but I had to tweak it to get it to compile.  Here's what I have so far in my main method:</p>
  
  <pre><code>        HttpWebRequest webRequest = null;
          HttpWebResponse webResponse = null;
          StreamReader responseStream = null;
  
          String twitterUser = Properties.Settings.Default.TwitterAccount;
          String twitterPassword = Properties.Settings.Default.TwitterPassword;
          String twitterHashtags = Properties.Settings.Default.TwitterHashtags;
  
          String twitterConsumerKey = Properties.Settings.Default.TwitterConsumerKey;
          String twitterConsumerSecret = Properties.Settings.Default.TwitterConsumerSecret;
          String twitterAccessToken = Properties.Settings.Default.TwitterAccessTokens;
          String twitterAccessTokenSecret = Properties.Settings.Default.TwitterAccessTokenSecret;
  
          Int32 wait = 250;
  
          while (true) //Auto retry on error!
          {
              try
              {
                  var postData = "track=" + HttpUtility.UrlEncode(twitterHashtags);
                  var requestContentBuffer = Encoding.UTF8.GetBytes(postData);
  
                  webRequest = (HttpWebRequest)WebRequest.Create(new Uri("https://stream.twitter.com/1.1/statuses/filter.json"));
                  webRequest.Method = "POST";
                  webRequest.ContentLength = requestContentBuffer.Length;
                  webRequest.ContentType = "application/x-www-form-urlencoded";
  
                  webRequest.UserAgent = "OAuthTwitterStream";
                  webRequest.Headers["Accept-Encoding"] = "deflate, gzip";
                  webRequest.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
  
                  OAuthRequestAuthorizer _requestAuthorizer = new OAuthRequestAuthorizer(twitterConsumerKey, twitterConsumerSecret, twitterAccessToken, twitterAccessTokenSecret);
  
                  _requestAuthorizer.Authorize(webRequest, postData);
  
                  using (var dataStream = webRequest.GetRequestStream())
                  {
                      dataStream.Write(requestContentBuffer, 0, requestContentBuffer.Length);
                  }
  
                  webResponse = (HttpWebResponse)webRequest.GetResponse();
                  responseStream = new StreamReader(webResponse.GetResponseStream());
  
                  while (true)
                  {
                      string jsonText = responseStream.ReadLine();
  
                      dynamic o = JsonConvert.DeserializeObject(jsonText);
  
                      if (o.disconnect == null) //Sometimes you get a disconnect response, we don't want our clients to see this.
                      {
                          //do something with tweet object
                      }
                  }
  
              }
              catch (WebException ee)
              {
                  if (ee.Status == WebExceptionStatus.ProtocolError)
                  {
                      if (wait &lt; 10000)
                          wait = 10000;
                      else
                      {
                          if (wait &lt; 240000)
                              wait = wait * 2;
                      }
                  }
  
                  Console.Error.WriteLine(ee.Message);
  
              }
              catch (Exception ee)
              {
                  Console.Error.WriteLine(ee.Message);
              }
              finally
              {
                  if (webRequest != null)
                  {
                      webRequest.Abort();
                  }
                  if (responseStream != null)
                  {
                      responseStream.Close();
                      responseStream = null;
                  }
  
                  if (webResponse != null)
                  {
                      webResponse.Close();
                      webResponse = null;
                  }
                  Console.WriteLine("Waiting: " + wait);
                  Thread.Sleep(wait);
              }
          }
  </code></pre>
  
  <p>And here is the Oauth class:</p>
  
  <pre><code>using System;
  using System.Security.Cryptography;
  using System.Collections.Generic;
  using System.Text;
  using System.Web;
  
  namespace OAuth
  {
      public class OAuthBase
      {
  
          /// &lt;summary&gt;
          /// Provides a predefined set of algorithms that are supported officially by the protocol
          /// &lt;/summary&gt;
          public enum SignatureTypes
          {
              HMACSHA1,
              PLAINTEXT,
              RSASHA1
          }
  
          /// &lt;summary&gt;
          /// Provides an internal structure to sort the query parameter
          /// &lt;/summary&gt;
          protected class QueryParameter
          {
              private string name = null;
              private string value = null;
  
              public QueryParameter(string name, string value)
              {
                  this.name = name;
                  this.value = value;
              }
  
              public string Name
              {
                  get { return name; }
              }
  
              public string Value
              {
                  get { return value; }
              }
          }
  
          /// &lt;summary&gt;
          /// Comparer class used to perform the sorting of the query parameters
          /// &lt;/summary&gt;
          protected class QueryParameterComparer : IComparer&lt;QueryParameter&gt;
          {
  
              #region IComparer&lt;QueryParameter&gt; Members
  
              public int Compare(QueryParameter x, QueryParameter y)
              {
                  if (x.Name == y.Name)
                  {
                      return string.Compare(x.Value, y.Value);
                  }
                  else
                  {
                      return string.Compare(x.Name, y.Name);
                  }
              }
  
              #endregion
          }
  
          protected const string OAuthVersion = "1.0";
          protected const string OAuthParameterPrefix = "oauth_";
  
          //
          // List of know and used oauth parameters' names
          //        
          protected const string OAuthConsumerKeyKey = "oauth_consumer_key";
          protected const string OAuthCallbackKey = "oauth_callback";
          protected const string OAuthVersionKey = "oauth_version";
          protected const string OAuthSignatureMethodKey = "oauth_signature_method";
          protected const string OAuthSignatureKey = "oauth_signature";
          protected const string OAuthTimestampKey = "oauth_timestamp";
          protected const string OAuthNonceKey = "oauth_nonce";
          protected const string OAuthTokenKey = "oauth_token";
          protected const string OAuthTokenSecretKey = "oauth_token_secret";
  
          protected const string HMACSHA1SignatureType = "HMAC-SHA1";
          protected const string PlainTextSignatureType = "PLAINTEXT";
          protected const string RSASHA1SignatureType = "RSA-SHA1";
  
          protected Random random = new Random();
  
          protected string unreservedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~";
  
          /// &lt;summary&gt;
          /// Helper function to compute a hash value
          /// &lt;/summary&gt;
          /// &lt;param name="hashAlgorithm"&gt;The hashing algoirhtm used. If that algorithm needs some initialization, like HMAC and its derivatives, they should be initialized prior to passing it to this function&lt;/param&gt;
          /// &lt;param name="data"&gt;The data to hash&lt;/param&gt;
          /// &lt;returns&gt;a Base64 string of the hash value&lt;/returns&gt;
          private string ComputeHash(HashAlgorithm hashAlgorithm, string data)
          {
              if (hashAlgorithm == null)
              {
                  throw new ArgumentNullException("hashAlgorithm");
              }
  
              if (string.IsNullOrEmpty(data))
              {
                  throw new ArgumentNullException("data");
              }
  
              byte[] dataBuffer = System.Text.Encoding.ASCII.GetBytes(data);
              byte[] hashBytes = hashAlgorithm.ComputeHash(dataBuffer);
  
              return Convert.ToBase64String(hashBytes);
          }
  
          /// &lt;summary&gt;
          /// Internal function to cut out all non oauth query string parameters (all parameters not begining with "oauth_")
          /// &lt;/summary&gt;
          /// &lt;param name="parameters"&gt;The query string part of the Url&lt;/param&gt;
          /// &lt;returns&gt;A list of QueryParameter each containing the parameter name and value&lt;/returns&gt;
          private List&lt;QueryParameter&gt; GetQueryParameters(string parameters)
          {
              if (parameters.StartsWith("?"))
              {
                  parameters = parameters.Remove(0, 1);
              }
  
              List&lt;QueryParameter&gt; result = new List&lt;QueryParameter&gt;();
  
              if (!string.IsNullOrEmpty(parameters))
              {
                  string[] p = parameters.Split('&amp;');
                  foreach (string s in p)
                  {
                      if (!string.IsNullOrEmpty(s) &amp;&amp; !s.StartsWith(OAuthParameterPrefix))
                      {
                          if (s.IndexOf('=') &gt; -1)
                          {
                              string[] temp = s.Split('=');
                              result.Add(new QueryParameter(temp[0], temp[1]));
                          }
                          else
                          {
                              result.Add(new QueryParameter(s, string.Empty));
                          }
                      }
                  }
              }
  
              return result;
          }
  
          /// &lt;summary&gt;
          /// This is a different Url Encode implementation since the default .NET one outputs the percent encoding in lower case.
          /// While this is not a problem with the percent encoding spec, it is used in upper case throughout OAuth
          /// &lt;/summary&gt;
          /// &lt;param name="value"&gt;The value to Url encode&lt;/param&gt;
          /// &lt;returns&gt;Returns a Url encoded string&lt;/returns&gt;
          protected string UrlEncode(string value)
          {
              StringBuilder result = new StringBuilder();
  
              foreach (char symbol in value)
              {
                  if (unreservedChars.IndexOf(symbol) != -1)
                  {
                      result.Append(symbol);
                  }
                  else
                  {
                      result.Append('%' + String.Format("{0:X2}", (int)symbol));
                  }
              }
  
              return result.ToString();
          }
  
          /// &lt;summary&gt;
          /// Normalizes the request parameters according to the spec
          /// &lt;/summary&gt;
          /// &lt;param name="parameters"&gt;The list of parameters already sorted&lt;/param&gt;
          /// &lt;returns&gt;a string representing the normalized parameters&lt;/returns&gt;
          protected string NormalizeRequestParameters(IList&lt;QueryParameter&gt; parameters)
          {
              StringBuilder sb = new StringBuilder();
              QueryParameter p = null;
              for (int i = 0; i &lt; parameters.Count; i++)
              {
                  p = parameters[i];
                  sb.AppendFormat("{0}={1}", p.Name, p.Value);
  
                  if (i &lt; parameters.Count - 1)
                  {
                      sb.Append("&amp;");
                  }
              }
  
              return sb.ToString();
          }
  
          /// &lt;summary&gt;
          /// Generate the signature base that is used to produce the signature
          /// &lt;/summary&gt;
          /// &lt;param name="url"&gt;The full url that needs to be signed including its non OAuth url parameters&lt;/param&gt;
          /// &lt;param name="consumerKey"&gt;The consumer key&lt;/param&gt;        
          /// &lt;param name="token"&gt;The token, if available. If not available pass null or an empty string&lt;/param&gt;
          /// &lt;param name="tokenSecret"&gt;The token secret, if available. If not available pass null or an empty string&lt;/param&gt;
          /// &lt;param name="httpMethod"&gt;The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)&lt;/param&gt;
          /// &lt;param name="signatureType"&gt;The signature type. To use the default values use &lt;see cref="OAuthBase.SignatureTypes"&gt;OAuthBase.SignatureTypes&lt;/see&gt;.&lt;/param&gt;
          /// &lt;returns&gt;The signature base&lt;/returns&gt;
          public string GenerateSignatureBase(Uri url, string consumerKey, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, out string normalizedRequestParameters)
          {
              if (token == null)
              {
                  token = string.Empty;
              }
  
              if (tokenSecret == null)
              {
                  tokenSecret = string.Empty;
              }
  
              if (string.IsNullOrEmpty(consumerKey))
              {
                  throw new ArgumentNullException("consumerKey");
              }
  
              if (string.IsNullOrEmpty(httpMethod))
              {
                  throw new ArgumentNullException("httpMethod");
              }
  
              if (string.IsNullOrEmpty(signatureType))
              {
                  throw new ArgumentNullException("signatureType");
              }
  
              normalizedUrl = null;
              normalizedRequestParameters = null;
  
              List&lt;QueryParameter&gt; parameters = GetQueryParameters(url.Query);
              parameters.Add(new QueryParameter(OAuthVersionKey, OAuthVersion));
              parameters.Add(new QueryParameter(OAuthNonceKey, nonce));
              parameters.Add(new QueryParameter(OAuthTimestampKey, timeStamp));
              parameters.Add(new QueryParameter(OAuthSignatureMethodKey, signatureType));
              parameters.Add(new QueryParameter(OAuthConsumerKeyKey, consumerKey));
  
              if (!string.IsNullOrEmpty(token))
              {
                  parameters.Add(new QueryParameter(OAuthTokenKey, token));
              }
  
              parameters.Sort(new QueryParameterComparer());
  
              normalizedUrl = string.Format("{0}://{1}", url.Scheme, url.Host);
              if (!((url.Scheme == "http" &amp;&amp; url.Port == 80) || (url.Scheme == "https" &amp;&amp; url.Port == 443)))
              {
                  normalizedUrl += ":" + url.Port;
              }
              normalizedUrl += url.AbsolutePath;
              normalizedRequestParameters = NormalizeRequestParameters(parameters);
  
              StringBuilder signatureBase = new StringBuilder();
              signatureBase.AppendFormat("{0}&amp;", httpMethod.ToUpper());
              signatureBase.AppendFormat("{0}&amp;", UrlEncode(normalizedUrl));
              signatureBase.AppendFormat("{0}", UrlEncode(normalizedRequestParameters));
  
              return signatureBase.ToString();
          }
  
          /// &lt;summary&gt;
          /// Generate the signature value based on the given signature base and hash algorithm
          /// &lt;/summary&gt;
          /// &lt;param name="signatureBase"&gt;The signature based as produced by the GenerateSignatureBase method or by any other means&lt;/param&gt;
          /// &lt;param name="hash"&gt;The hash algorithm used to perform the hashing. If the hashing algorithm requires initialization or a key it should be set prior to calling this method&lt;/param&gt;
          /// &lt;returns&gt;A base64 string of the hash value&lt;/returns&gt;
          public string GenerateSignatureUsingHash(string signatureBase, HashAlgorithm hash)
          {
              return ComputeHash(hash, signatureBase);
          }
  
          /// &lt;summary&gt;
          /// Generates a signature using the HMAC-SHA1 algorithm
          /// &lt;/summary&gt;      
          /// &lt;param name="url"&gt;The full url that needs to be signed including its non OAuth url parameters&lt;/param&gt;
          /// &lt;param name="consumerKey"&gt;The consumer key&lt;/param&gt;
          /// &lt;param name="consumerSecret"&gt;The consumer seceret&lt;/param&gt;
          /// &lt;param name="token"&gt;The token, if available. If not available pass null or an empty string&lt;/param&gt;
          /// &lt;param name="tokenSecret"&gt;The token secret, if available. If not available pass null or an empty string&lt;/param&gt;
          /// &lt;param name="httpMethod"&gt;The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)&lt;/param&gt;
          /// &lt;returns&gt;A base64 string of the hash value&lt;/returns&gt;
          public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, out string normalizedUrl, out string normalizedRequestParameters)
          {
              return GenerateSignature(url, consumerKey, consumerSecret, token, tokenSecret, httpMethod, timeStamp, nonce, SignatureTypes.HMACSHA1, out normalizedUrl, out normalizedRequestParameters);
          }
  
          /// &lt;summary&gt;
          /// Generates a signature using the specified signatureType 
          /// &lt;/summary&gt;      
          /// &lt;param name="url"&gt;The full url that needs to be signed including its non OAuth url parameters&lt;/param&gt;
          /// &lt;param name="consumerKey"&gt;The consumer key&lt;/param&gt;
          /// &lt;param name="consumerSecret"&gt;The consumer seceret&lt;/param&gt;
          /// &lt;param name="token"&gt;The token, if available. If not available pass null or an empty string&lt;/param&gt;
          /// &lt;param name="tokenSecret"&gt;The token secret, if available. If not available pass null or an empty string&lt;/param&gt;
          /// &lt;param name="httpMethod"&gt;The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)&lt;/param&gt;
          /// &lt;param name="signatureType"&gt;The type of signature to use&lt;/param&gt;
          /// &lt;returns&gt;A base64 string of the hash value&lt;/returns&gt;
          public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, SignatureTypes signatureType, out string normalizedUrl, out string normalizedRequestParameters)
          {
              normalizedUrl = null;
              normalizedRequestParameters = null;
  
              switch (signatureType)
              {
                  case SignatureTypes.PLAINTEXT:
                      return HttpUtility.UrlEncode(string.Format("{0}&amp;{1}", consumerSecret, tokenSecret));
                  case SignatureTypes.HMACSHA1:
                      string signatureBase = GenerateSignatureBase(url, consumerKey, token, tokenSecret, httpMethod, timeStamp, nonce, HMACSHA1SignatureType, out normalizedUrl, out normalizedRequestParameters);
  
                      HMACSHA1 hmacsha1 = new HMACSHA1();
                      hmacsha1.Key = Encoding.ASCII.GetBytes(string.Format("{0}&amp;{1}", UrlEncode(consumerSecret), string.IsNullOrEmpty(tokenSecret) ? "" : UrlEncode(tokenSecret)));
  
                      return GenerateSignatureUsingHash(signatureBase, hmacsha1);
                  case SignatureTypes.RSASHA1:
                      throw new NotImplementedException();
                  default:
                      throw new ArgumentException("Unknown signature type", "signatureType");
              }
          }
  
          /// &lt;summary&gt;
          /// Generate the timestamp for the signature        
          /// &lt;/summary&gt;
          /// &lt;returns&gt;&lt;/returns&gt;
          public virtual string GenerateTimeStamp()
          {
              // Default implementation of UNIX time of the current UTC time
              TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
              return Convert.ToInt64(ts.TotalSeconds).ToString();
          }
  
          /// &lt;summary&gt;
          /// Generate a nonce
          /// &lt;/summary&gt;
          /// &lt;returns&gt;&lt;/returns&gt;
          public virtual string GenerateNonce()
          {
              // Just a simple implementation of a random number between 123400 and 9999999
              return random.Next(123400, 9999999).ToString();
          }
  
      }
  }
  </code></pre>
  
  <p>And finally the OAuthRequestAuthorizer class:</p>
  
  <pre><code>using OAuth;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Net;
  using System.Web;
  
  namespace LiveTwitter
  {
      public interface IRequestAuthorizer
      {
          void Authorize(HttpWebRequest request, string postData);
      }
  
      public class OAuthRequestAuthorizer : OAuthBase, IRequestAuthorizer
      {
          private readonly string _twitterConsumerKey;
          private readonly string _twitterConsumerSecret;
          private readonly string _twitterAccessToken;
          private readonly string _twitterAccessTokenSecret;
  
          public OAuthRequestAuthorizer(string twitterConsumerKey, string twitterConsumerSecret, string twitterAccessToken, string twitterAccessTokenSecret)
          {
              _twitterConsumerKey = twitterConsumerKey;
              _twitterConsumerSecret = twitterConsumerSecret;
              _twitterAccessToken = twitterAccessToken;
              _twitterAccessTokenSecret = twitterAccessTokenSecret;
          }
  
          public override string GenerateNonce()
          {
              return new Nonce().Value;
          }
  
          private string BuildHeader(HttpWebRequest request, Uri uri)
          {
              var nonce = GenerateNonce();
              var timeStamp = GenerateTimeStamp();
  
              string normalizedUrl;
              string normalizedRequestParameters;
  
              var httpMethod = request.Method;
              var signature = GenerateSignature(uri, _twitterConsumerKey, _twitterConsumerSecret, _twitterAccessToken, _twitterAccessTokenSecret,
                                                httpMethod, timeStamp, nonce, out normalizedUrl,
                                                out normalizedRequestParameters);
  
              // https://dev.twitter.com/docs/auth/authorizing-request
              return
                  string.Format(
                      "OAuth oauth_consumer_key=\"{0}\", " +
                      "oauth_nonce=\"{1}\", " +
                      "oauth_signature=\"{2}\", " +
                      "oauth_signature_method=\"HMAC-SHA1\", " +
                      "oauth_timestamp=\"{3}\", " +
                      "oauth_token=\"{4}\", " +
                      "oauth_version=\"1.0\"",
  
                      UrlEncode(_twitterConsumerKey),
                      UrlEncode(_twitterConsumerKey),
                      UrlEncode(nonce),
                      UrlEncode(signature),
                      UrlEncode(timeStamp),
                      UrlEncode(_twitterAccessToken));
          }
  
          public void Authorize(HttpWebRequest request, string postData)
          {
              //NOTE: It's a must to collect all param either in the header/querystring or post body
              var baseUri = string.IsNullOrEmpty(postData) || request.Method.ToUpper() == "GET"
                          ? request.RequestUri
                          : new Uri(string.Format("{0}?{1}", request.RequestUri.AbsoluteUri, postData));
  
              request.Headers["Authorization"] = BuildHeader(request, baseUri);
          }
      }
  
      public class Nonce
      {
          public string Value { get; set; }
  
          public Nonce()
          {
              Value = Guid.NewGuid().ToString();
          }
      }
  }
  </code></pre>
  
  <p>I am using the correct API keys and I think I have the correct settings set up on the application.  Any idea why I keep getting a 401?  Also, if there is a simpler way to do this by all means let me know!</p>