/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso href="http://oauth.net/core/1.0#rfc.section.9.2" />
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(
OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (OAuthTools.IsNullOrBlank(tokenSecret))
{
tokenSecret = string.Empty;
}
consumerSecret = OAuthTools.UrlEncodeRelaxed(consumerSecret);
tokenSecret = OAuthTools.UrlEncodeRelaxed(tokenSecret);
if (signatureMethod != OAuthSignatureMethod.HmacSha1)
{
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
HMACSHA1 hmacshA1 = new HMACSHA1();
string s = consumerSecret + "&" + tokenSecret;
hmacshA1.Key = OAuthTools._encoding.GetBytes(s);
string str = OAuthTools.HashWith(signatureBase, (HashAlgorithm)hmacshA1);
return(signatureTreatment == OAuthSignatureTreatment.Escaped ? OAuthTools.UrlEncodeRelaxed(str) : str);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret.
/// This method is used when the token secret is currently unknown.
/// </summary>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer key</param>
/// <returns></returns>
public static string GetSignature(
OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret
)
=> GetSignature(signatureMethod, signatureTreatment, signatureBase, consumerSecret, null);
public static string GetSignature(OAuthSignatureMethod signatureMethod, OAuthSignatureTreatment signatureTreatment, string signatureBase, string consumerSecret, string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = string.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string text;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
HMACSHA1 hMACSHA = new HMACSHA1();
string s = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
hMACSHA.Key = _encoding.GetBytes(s);
text = signatureBase.HashWith(hMACSHA);
break;
}
case OAuthSignatureMethod.PlainText:
text = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
break;
default:
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
return((signatureTreatment == OAuthSignatureTreatment.Escaped) ? UrlEncodeRelaxed(text) : text);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret.
/// This method is used when the token secret is currently unknown.
/// </summary>
/// <seealso href="http://oauth.net/core/1.0#rfc.section.9.2" />
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer key</param>
/// <returns></returns>
public static string GetSignature(
OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret)
{
return(OAuthTools.GetSignature(signatureMethod, signatureTreatment, signatureBase, consumerSecret, (string)null));
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod, OAuthSignatureTreatment signatureTreatment,
string signatureBase, string consumerSecret, string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = string.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
#if !WINDOWS_UWP
HMACSHA1 crypto = new HMACSHA1();
string key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
#else
signature = signatureBase.HashWith(HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1));
#endif
break;
}
case OAuthSignatureMethod.HmacSha256:
{
HMACSHA256 crypto = new HMACSHA256();
string key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
break;
}
case OAuthSignatureMethod.PlainText:
{
signature = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1 and HMAC-SHA256 are currently supported.");
}
string result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
#if !PocketPC
case OAuthSignatureMethod.HmacSha1:
{
var key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
#if NETFX_CORE
var crypto = MacAlgorithmProvider.OpenAlgorithm("HMAC_SHA1");
signature = signatureBase.HashWith(_encoding.GetBytes(key), crypto);
#else
var crypto = new HMACSHA1();
crypto.Key = _encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
#endif
break;
}
#endif
case OAuthSignatureMethod.PlainText:
{
signature = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
break;
}
default:
#if PocketPC
throw new NotImplementedException("Only PlainText is currently supported.");
#else
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
#endif
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso href="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (IsNullOrBlank(tokenSecret))
{
tokenSecret = String.Empty;
}
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
case OAuthSignatureMethod.HmacSha256:
{
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
var key = string.Concat(consumerSecret, "&", tokenSecret);
#if WINRT
IBuffer keyMaterial = CryptographicBuffer.ConvertStringToBinary(key, _encoding);
string algorithm = OAuthSignatureMethod.HmacSha1 ? MacAlgorithmNames.HmacSha1 : MacAlgorithmNames.HmacSha256;
MacAlgorithmProvider hmacShaProvider = MacAlgorithmProvider.OpenAlgorithm(algorithm);
CryptographicKey macKey = hmacShaProvider.CreateKey(keyMaterial);
IBuffer dataToBeSigned = CryptographicBuffer.ConvertStringToBinary(signatureBase, _encoding);
IBuffer signatureBuffer = CryptographicEngine.Sign(macKey, dataToBeSigned);
signature = CryptographicBuffer.EncodeToBase64String(signatureBuffer);
#else
var crypto = signatureMethod == OAuthSignatureMethod.HmacSha1 ? (HMAC) new HMACSHA1() : new HMACSHA256();
crypto.Key = _encoding.GetBytes(key);
signature = HashWith(signatureBase, crypto);
#endif
break;
}
case OAuthSignatureMethod.RsaSha1:
signature = TextSigner.SignWithRsaSha1(signatureBase, consumerSecret);
break;
default:
throw new NotImplementedException("Only HMAC-SHA1, HMAC-SHA256 and RSA-SHA1 signatures are currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known
/// token secret.
/// </summary>
/// <seealso href="http://oauth.net/core/1.0#rfc.section.9.2" />
/// <param name="signatureMethod">
/// The hashing method
/// </param>
/// <param name="signatureTreatment">
/// The treatment to use on a signature value
/// </param>
/// <param name="signatureBase">
/// The signature base
/// </param>
/// <param name="consumerSecret">
/// The consumer secret
/// </param>
/// <param name="tokenSecret">
/// The token secret
/// </param>
/// <returns>
/// </returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod, OAuthSignatureTreatment signatureTreatment, string?signatureBase,
string?consumerSecret, string?tokenSecret)
{
if (string.IsNullOrWhiteSpace(signatureBase))
{
throw new NullReferenceException($"parameter {nameof(signatureBase)} must not be null, empty or whitespace");
}
if (string.IsNullOrWhiteSpace(consumerSecret))
{
throw new NullReferenceException($"parameter {nameof(consumerSecret)} must not be null, empty or whitespace");
}
if (string.IsNullOrWhiteSpace(tokenSecret))
{
tokenSecret = string.Empty;
}
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
var key = string.Concat(consumerSecret, "&", tokenSecret);
var crypto = new HMACSHA1
{
Key = _encoding.GetBytes(key)
};
signature = HashWith(signatureBase, crypto);
break;
}
case OAuthSignatureMethod.RsaSha1:
signature = TextSigner.SignWithRsaSha1(signatureBase, consumerSecret);
break;
default:
throw new NotImplementedException("Only HMAC-SHA1 and RSA-SHA1 signatures are currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret. This method is
/// used when the token secret is currently unknown.
/// </summary>
/// <seealso href="http://oauth.net/core/1.0#rfc.section.9.2" />
/// <param name="signatureMethod">
/// The hashing method
/// </param>
/// <param name="signatureTreatment">
/// The treatment to use on a signature value
/// </param>
/// <param name="signatureBase">
/// The signature base
/// </param>
/// <param name="consumerSecret">
/// The consumer key
/// </param>
/// <returns>
/// </returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod, OAuthSignatureTreatment signatureTreatment, string?signatureBase, string?consumerSecret)
{
if (string.IsNullOrWhiteSpace(signatureBase))
{
throw new NullReferenceException($"parameter {nameof(signatureBase)} must not be null, empty or whitespace");
}
if (string.IsNullOrWhiteSpace(consumerSecret))
{
throw new NullReferenceException($"parameter {nameof(consumerSecret)} must not be null, empty or whitespace");
}
return(GetSignature(signatureMethod, signatureTreatment, signatureBase, consumerSecret, null));
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(
OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string?consumerSecret,
string?tokenSecret
)
{
if (tokenSecret.IsEmpty())
{
tokenSecret = string.Empty;
}
if (consumerSecret.IsEmpty())
{
consumerSecret = string.Empty;
}
var unencodedConsumerSecret = consumerSecret !;
consumerSecret = Uri.EscapeDataString(consumerSecret !);
tokenSecret = Uri.EscapeDataString(tokenSecret !);
var signature = signatureMethod switch
{
HmacSha1 => GetHmacSignature(new HMACSHA1(), consumerSecret, tokenSecret, signatureBase),
HmacSha256 => GetHmacSignature(new HMACSHA256(), consumerSecret, tokenSecret, signatureBase),
RsaSha1 => GetRsaSignature(),
PlainText => $"{consumerSecret}&{tokenSecret}",
_ => throw new NotImplementedException("Only HMAC-SHA1, HMAC-SHA256, and RSA-SHA1 are currently supported.")
};
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
string GetRsaSignature()
{
using var provider = new RSACryptoServiceProvider { PersistKeyInCsp = false };
provider.FromXmlString2(unencodedConsumerSecret);
var hasher = new SHA1Managed();
var hash = hasher.ComputeHash(Encoding.GetBytes(signatureBase));
return(Convert.ToBase64String(provider.SignHash(hash, CryptoConfig.MapNameToOID("SHA1"))));
}
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso href="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (IsNullOrBlank(tokenSecret))
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
var crypto = new HMACSHA1();
var key = string.Concat(consumerSecret, "&", tokenSecret);
crypto.Key = _encoding.GetBytes(key);
signature = HashWith(signatureBase, crypto);
break;
}
case OAuthSignatureMethod.HmacSha256: {
var crypto = new HMACSHA256();
var key = string.Concat(consumerSecret, "&", tokenSecret);
crypto.Key = _encoding.GetBytes(key);
signature = HashWith(signatureBase, crypto);
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
var key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
var keyMaterial = CryptographicBuffer.ConvertStringToBinary(key, BinaryStringEncoding.Utf8);
var hmacSha1Provider = MacAlgorithmProvider.OpenAlgorithm("HMAC_SHA1");
var macKey = hmacSha1Provider.CreateKey(keyMaterial);
var dataToBeSigned = CryptographicBuffer.ConvertStringToBinary(signatureBase, BinaryStringEncoding.Utf8);
var signatureBuffer = CryptographicEngine.Sign(macKey, dataToBeSigned);
signature = CryptographicBuffer.EncodeToBase64String(signatureBuffer);
break;
}
case OAuthSignatureMethod.PlainText:
{
signature = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <a href="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (string.IsNullOrEmpty(tokenSecret))
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
var key = string.Format("{0}&{1}", consumerSecret, tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
var keyData = _encoding.GetBytes(key);
#if USE_BOUNCYCASTLE
var digest = new Org.BouncyCastle.Crypto.Digests.Sha1Digest();
var crypto = new Org.BouncyCastle.Crypto.Macs.HMac(digest);
crypto.Init(new Org.BouncyCastle.Crypto.Parameters.KeyParameter(keyData));
signature = signatureBase.HashWith(crypto);
#else
using (var digest = new System.Security.Cryptography.HMACSHA1(keyData))
signature = signatureBase.HashWith(digest);
#endif
break;
}
case OAuthSignatureMethod.PlainText:
{
signature = key;
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
#if NETFX_CORE
throw new NotImplementedException("What goes here?");
#else
var crypto = new HMACSHA1();
var key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = _encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
break;
#endif
}
default:
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <a href="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureProvider">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(
ISignatureProvider signatureProvider,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (string.IsNullOrEmpty(tokenSecret))
{
tokenSecret = string.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
var data = _encoding.GetBytes(signatureBase);
var hash = signatureProvider.CalculateSignature(data, consumerSecret, tokenSecret);
var signature = hash;
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
var crypto = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha1);
var key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
signature = signatureBase.HashWith(crypto, key);
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret.
/// This method is used when the token secret is currently unknown.
/// </summary>
/// <seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer key</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod, OAuthSignatureTreatment signatureTreatment,
string signatureBase, string consumerSecret)
{
return GetSignature(signatureMethod, signatureTreatment, signatureBase, consumerSecret, null);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod, OAuthSignatureTreatment signatureTreatment,
string signatureBase, string consumerSecret, string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = string.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
#if !WINDOWS_UWP
HMACSHA1 crypto = new HMACSHA1();
string key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
#else
signature = signatureBase.HashWith(HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1));
#endif
break;
}
case OAuthSignatureMethod.HmacSha256:
{
HMACSHA256 crypto = new HMACSHA256();
string key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
break;
}
case OAuthSignatureMethod.PlainText:
{
signature = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1 and HMAC-SHA256 are currently supported.");
}
string result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return result;
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase, string consumerSecret, string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = string.Empty;
}
var unencodedConsumerSecret = consumerSecret;
consumerSecret = Uri.EscapeDataString(consumerSecret);
tokenSecret = Uri.EscapeDataString(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
var crypto = new HMACSHA1();
var key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
break;
}
case OAuthSignatureMethod.HmacSha256:
{
var crypto = new HMACSHA256();
var key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
break;
}
case OAuthSignatureMethod.RsaSha1:
{
using (var provider = new RSACryptoServiceProvider {
PersistKeyInCsp = false
})
{
provider.FromXmlString2(unencodedConsumerSecret);
SHA1Managed hasher = new SHA1Managed();
byte[] hash = hasher.ComputeHash(encoding.GetBytes(signatureBase));
signature = Convert.ToBase64String(provider.SignHash(hash, CryptoConfig.MapNameToOID("SHA1")));
}
break;
}
case OAuthSignatureMethod.PlainText:
{
signature = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1, HMAC-SHA256, and RSA-SHA1 are currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
#if !PocketPC
case OAuthSignatureMethod.HmacSha1:
{
var crypto = new HMACSHA1();
var key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = _encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
break;
}
#endif
case OAuthSignatureMethod.PlainText:
{
signature = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
break;
}
default:
#if PocketPC
throw new NotImplementedException("Only PlainText is currently supported.");
#else
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
#endif
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return result;
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret.
/// This method is used when the token secret is currently unknown.
/// </summary>
/// <a href="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureProvider">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer key</param>
/// <returns></returns>
public static string GetSignature(ISignatureProvider signatureProvider, OAuthSignatureTreatment signatureTreatment, string signatureBase, string consumerSecret)
{
return GetSignature(signatureProvider, signatureTreatment, signatureBase, consumerSecret, null);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <a href="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureProvider">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(
ISignatureProvider signatureProvider,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (string.IsNullOrEmpty(tokenSecret))
{
tokenSecret = string.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
var data = _encoding.GetBytes(signatureBase);
var hash = signatureProvider.CalculateSignature(data, consumerSecret, tokenSecret);
var signature = hash;
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return result;
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso href="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (IsNullOrBlank(tokenSecret))
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
var key = String.Concat(consumerSecret, "&", tokenSecret);
#if NETFX_CORE
var crypto = MacAlgorithmProvider.OpenAlgorithm(MacAlgorithmNames.HmacSha1);
var cryptoKey = crypto.CreateKey(CryptographicBuffer.ConvertStringToBinary(key, BinaryStringEncoding.Utf8));
signature = HashWith(signatureBase, cryptoKey);
#endif
#if !NETFX_CORE
var crypto = new HMACSHA1();
crypto.Key = _encoding.GetBytes(key);
signature = HashWith(signatureBase, crypto);
#endif
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return result;
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod, OAuthSignatureTreatment signatureTreatment,
string signatureBase, string consumerSecret, string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = string.Empty;
}
var unencodedConsumerSecret = consumerSecret;
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
#if !WINDOWS_UWP
HMACSHA1 crypto = new HMACSHA1();
string key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
#else
signature = signatureBase.HashWith(HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Sha1));
#endif
break;
}
case OAuthSignatureMethod.HmacSha256:
{
HMACSHA256 crypto = new HMACSHA256();
string key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
crypto.Key = encoding.GetBytes(key);
signature = signatureBase.HashWith(crypto);
break;
}
case OAuthSignatureMethod.RsaSha1:
{
using (MemoryStream stream = new MemoryStream())
{
Org.BouncyCastle.OpenSsl.PemReader pemReader;
Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair keyPair;
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write(unencodedConsumerSecret);
writer.Flush();
stream.Position = 0;
pemReader = new Org.BouncyCastle.OpenSsl.PemReader(new StreamReader(stream));
keyPair = (Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair)pemReader.ReadObject();
}
Org.BouncyCastle.Crypto.AsymmetricKeyParameter priKey = (Org.BouncyCastle.Crypto.AsymmetricKeyParameter)keyPair.Private;
Org.BouncyCastle.Crypto.Parameters.RsaPrivateCrtKeyParameters rsaPriv = (Org.BouncyCastle.Crypto.Parameters.RsaPrivateCrtKeyParameters)priKey;
RSAParameters RSAKeyInfo = Org.BouncyCastle.Security.DotNetUtilities.ToRSAParameters(rsaPriv);
using (RSACryptoServiceProvider provider = new RSACryptoServiceProvider()) // { PersistKeyInCsp = false };
{
provider.ImportParameters(RSAKeyInfo);
SHA1Managed hasher = new SHA1Managed();
byte[] hash = hasher.ComputeHash(encoding.GetBytes(signatureBase));
Trace.WriteLine(string.Format("Hashing [{0}]", signatureBase));
signature = Convert.ToBase64String(provider.SignHash(hash, CryptoConfig.MapNameToOID("SHA1")));
Trace.WriteLine(string.Format("SHA1 Signature [{0}]", signature));
}
}
}
break;
case OAuthSignatureMethod.PlainText:
{
signature = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1, HMAC-SHA256, and RSA-SHA1 are currently supported.");
}
string result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return(result);
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret.
/// This method is used when the token secret is currently unknown.
/// </summary>
/// <a href="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureProvider">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer key</param>
/// <returns></returns>
public static string GetSignature(ISignatureProvider signatureProvider, OAuthSignatureTreatment signatureTreatment, string signatureBase, string consumerSecret)
{
return(GetSignature(signatureProvider, signatureTreatment, signatureBase, consumerSecret, null));
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso href="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (IsNullOrBlank(tokenSecret))
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
var key = string.Concat(consumerSecret, "&", tokenSecret);
var crypto = new HMACSHA1(_encoding.GetBytes(key));
signature = HashWith(signatureBase, crypto);
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return result;
}
/// <summary>
/// Creates a signature value given a signature base and the consumer secret and a known token secret.
/// </summary>
/// <seealso cref="http://oauth.net/core/1.0#rfc.section.9.2"/>
/// <param name="signatureMethod">The hashing method</param>
/// <param name="signatureTreatment">The treatment to use on a signature value</param>
/// <param name="signatureBase">The signature base</param>
/// <param name="consumerSecret">The consumer secret</param>
/// <param name="tokenSecret">The token secret</param>
/// <returns></returns>
public static string GetSignature(OAuthSignatureMethod signatureMethod,
OAuthSignatureTreatment signatureTreatment,
string signatureBase,
string consumerSecret,
string tokenSecret)
{
if (tokenSecret.IsNullOrBlank())
{
tokenSecret = String.Empty;
}
consumerSecret = UrlEncodeRelaxed(consumerSecret);
tokenSecret = UrlEncodeRelaxed(tokenSecret);
string signature;
switch (signatureMethod)
{
case OAuthSignatureMethod.HmacSha1:
{
var key = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
var keyMaterial = CryptographicBuffer.ConvertStringToBinary(key, BinaryStringEncoding.Utf8);
var hmacSha1Provider = MacAlgorithmProvider.OpenAlgorithm("HMAC_SHA1");
var macKey = hmacSha1Provider.CreateKey(keyMaterial);
var dataToBeSigned = CryptographicBuffer.ConvertStringToBinary(signatureBase, BinaryStringEncoding.Utf8);
var signatureBuffer = CryptographicEngine.Sign(macKey, dataToBeSigned);
signature = CryptographicBuffer.EncodeToBase64String(signatureBuffer);
break;
}
case OAuthSignatureMethod.PlainText:
{
signature = "{0}&{1}".FormatWith(consumerSecret, tokenSecret);
break;
}
default:
throw new NotImplementedException("Only HMAC-SHA1 is currently supported.");
}
var result = signatureTreatment == OAuthSignatureTreatment.Escaped
? UrlEncodeRelaxed(signature)
: signature;
return result;
}
