public void HashCode()
{
HashSet <int> hashCodes = new HashSet <int>();
foreach (var item in TokenScope.EnumerateValues())
{
Assert.True(hashCodes.Add(item.GetHashCode()));
}
int loop1 = 0;
foreach (var item1 in TokenScope.EnumerateValues())
{
int loop2 = 0;
foreach (var item2 in TokenScope.EnumerateValues())
{
if (loop1 < loop2)
{
Assert.True(hashCodes.Add((item1 | item2).GetHashCode()));
}
else
{
Assert.False(hashCodes.Add((item1 | item2).GetHashCode()));
}
loop2++;
}
loop1++;
}
}
public ServiceBusOptionSet()
{
Add<string>("ns=", "The service bus namespace",
x => ServiceUri = ServiceBusEnvironment.CreateServiceUri("sb", x, "Benchmark"));
Add<string>("keyname=", "The access key name", x => _keyName = x);
Add<string>("key=", "The access key", x => _accessKey = x);
Add<int>("connections=", "The number of connections to configure for the service point manager",
x => DefaultConnections = x);
_tokenTimeToLive = TimeSpan.FromDays(1);
_tokenScope = TokenScope.Namespace;
OperationTimeout = TimeSpan.FromSeconds(60.0);
RetryMinBackoff = TimeSpan.FromMilliseconds(100.0);
RetryMaxBackoff = TimeSpan.FromSeconds(20.0);
RetryLimit = 10;
TransportType = Microsoft.ServiceBus.Messaging.TransportType.Amqp;
AmqpTransportSettings = new AmqpTransportSettings
{
BatchFlushInterval = TimeSpan.FromMilliseconds(3.0)
};
NetMessagingTransportSettings = new NetMessagingTransportSettings
{
BatchFlushInterval = TimeSpan.FromMilliseconds(3.0)
};
DefaultConnections = ServicePointManager.DefaultConnectionLimit;
}
public async Task <AuthenticationResult> GetAuthAsync(TargetUri targetUri, TokenScope scope, int requestTimeout, Uri restRootUrl, string username, string password)
{
// use the provided username and password and attempt a Basic Auth request to a known
// REST API resource.
string basicAuthValue = string.Format("{0}:{1}", username, password);
byte[] authBytes = Encoding.UTF8.GetBytes(basicAuthValue);
basicAuthValue = Convert.ToBase64String(authBytes);
var authHeader = "Basic " + basicAuthValue;
var result = await RestClient.TryGetUser(targetUri, requestTimeout, restRootUrl, authHeader);
if (result.Type.Equals(AuthenticationResultType.Success))
{
// Success with username/passord indicates 2FA is not on so
// the 'token' is actually the password if we had a
// successful call then the password is good.
var token = new Token(password, TokenType.Personal);
if (!string.IsNullOrWhiteSpace(result.RemoteUsername) && !username.Equals(result.RemoteUsername))
{
Trace.WriteLine($"Remote username [{result.RemoteUsername}] != [{username}] supplied username");
return(new AuthenticationResult(AuthenticationResultType.Success, token, result.RemoteUsername));
}
return(new AuthenticationResult(AuthenticationResultType.Success, token));
}
Trace.WriteLine("authentication failed");
return(result);
}
/// <summary></summary>
/// <param name="keyName"></param>
/// <param name="sharedAccessKey"></param>
/// <param name="customKeyEncoder"></param>
/// <param name="tokenTimeToLive"></param>
/// <param name="tokenScope"></param>
protected SharedAccessSignatureTokenProvider(string keyName, string sharedAccessKey, Func <string, byte[]> customKeyEncoder, TimeSpan tokenTimeToLive, TokenScope tokenScope)
{
Guard.ArgumentNotNullOrWhiteSpace(nameof(keyName), keyName);
if (keyName.Length > SharedAccessSignatureToken.MaxKeyNameLength)
{
throw new ArgumentOutOfRangeException(
nameof(keyName),
Resources.ArgumentStringTooBig.FormatForUser(nameof(keyName), SharedAccessSignatureToken.MaxKeyNameLength));
}
Guard.ArgumentNotNullOrWhiteSpace(nameof(sharedAccessKey), sharedAccessKey);
if (sharedAccessKey.Length > SharedAccessSignatureToken.MaxKeyLength)
{
throw new ArgumentOutOfRangeException(
nameof(sharedAccessKey),
Resources.ArgumentStringTooBig.FormatForUser(nameof(sharedAccessKey), SharedAccessSignatureToken.MaxKeyLength));
}
this.keyName = keyName;
this.tokenTimeToLive = tokenTimeToLive;
this.encodedSharedAccessKey = customKeyEncoder != null?
customKeyEncoder(sharedAccessKey) :
MessagingTokenProviderKeyEncoder(sharedAccessKey);
this.tokenScope = tokenScope;
}
public static void Validate(TokenScope value)
{
if (!TokenScopeHelper.IsDefined(value))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidEnumArgumentException("value", (int)value, typeof(TokenScope)));
}
}
public ServiceBusOptionSet()
{
Add <string>("ns=", "The service bus namespace",
x => ServiceUri = new UriBuilder
{
Scheme = "sb",
Host = $"{x}.servicebus.windows.net",
Path = "Benchmark"
}.Uri);
Add <string>("keyname=", "The access key name", x => _keyName = x);
Add <string>("key=", "The access key", x => _accessKey = x);
Add <int>("connections=", "The number of connections to configure for the service point manager", x => DefaultConnections = x);
Add <bool>("split:", "Split into two bus instances to leverage separate connections", x => Split = x);
_tokenTimeToLive = TimeSpan.FromDays(1);
_tokenScope = TokenScope.Namespace;
TransportType = TransportType.Amqp;
OperationTimeout = TimeSpan.FromSeconds(60.0);
RetryMinBackoff = TimeSpan.FromMilliseconds(100.0);
RetryMaxBackoff = TimeSpan.FromSeconds(20.0);
RetryLimit = 10;
DefaultConnections = ServicePointManager.DefaultConnectionLimit;
}
public GetResolutionWindow(User User, TokenScope Scope)
{
this.User = User;
this.Scope = Scope;
InitializeComponent();
VerifySecretKeyCommand = new DelegateCommand(VerifySecretKey);
}
public static bool IsDefined(TokenScope v)
{
if (v == TokenScope.Entity)
{
return(true);
}
return(v == TokenScope.Namespace);
}
private Uri GetAuthorizationUri(TokenScope scope)
{
const string AuthorizationUrl = "{0}?response_type=code&client_id={1}&state=authenticated&scope={2}&redirect_uri={3}";
var authorityUrl = string.Format(System.Globalization.CultureInfo.InvariantCulture,
AuthorizationUrl,
AuthorizeUrlPath,
ConsumerKey,
scope.ToString(),
CallbackUri);
return(new Uri(new Uri("https://bitbucket.org"), authorityUrl));
}
public static void Main(string[] args)
{
string queueName = ConfigurationManager.AppSettings["QueueName"];
string serviceNamespace = ConfigurationManager.AppSettings["ServiceNamespace"];
string policyName = ConfigurationManager.AppSettings["SAS_PolicyName"];
string key = ConfigurationManager.AppSettings["SAS_Key"];
// Continuously process messages sent to the "TestQueue"
while (true)
{
Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty);
TimeSpan timeSpan = new TimeSpan(480, 30, 30);
TokenScope tokenScope = TokenScope.Namespace;
TokenProvider tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(
policyName,
key,
timeSpan,
tokenScope
);
var messagingFactory = MessagingFactory.Create(uri, tokenProvider);
QueueClient qClient = messagingFactory.CreateQueueClient(queueName, ReceiveMode.PeekLock);
BrokeredMessage message = qClient.Receive();
if (message != null)
{
try
{
QueueMessage msg = message.GetBody <QueueMessage>();
Console.WriteLine(
$"Received {msg.Value} from {msg.ByPerson} queued at {msg.QueuedTime}"
);
//Console.WriteLine("MessageID: " + message.MessageId);
// Remove message from queue
message.Complete();
Console.WriteLine();
System.Threading.Thread.Sleep(1000);
}
catch (Exception e)
{
// Indicate a problem, unlock message in queue
message.Abandon();
}
}
}
}
/// <summary>
/// Run the OAuth dance to get a new request_token
/// </summary>
/// <param name="targetUri"></param>
/// <param name="scope"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
private async Task <string> Authorize(TargetUri targetUri, TokenScope scope, CancellationToken cancellationToken)
{
string url = GetAuthorizationUrl(scope);
//Open the browser to prompt the user to authorize the token request
Process.Start(url);
string rawUrlData;
try
{
//Start a temporary server to handle the callback request and await for the reply
rawUrlData = await SimpleServer.WaitForURLAsync(CallbackUri, cancellationToken);
}
catch (Exception ex)
{
string message;
if (ex.InnerException != null && ex.InnerException.GetType().IsAssignableFrom(typeof(TimeoutException)))
{
message = "Timeout awaiting response from Host service.";
}
else
{
message = "Unable to receive callback from OAuth service provider";
}
throw new Exception(message, ex);
}
//Parse the callback url
Dictionary <string, string> qs = GetQueryParameters(rawUrlData);
// look for a request_token code in the parameters
string authCode = GetAuthenticationCode(qs);
if (string.IsNullOrWhiteSpace(authCode))
{
var error_desc = GetErrorDescription(qs);
throw new Exception("Request for an OAuth request_token was denied" + error_desc);
}
return(authCode);
}
private static void SendMessage()
{
string queueName = ConfigurationManager.AppSettings["QueueName"];
string serviceNamespace = ConfigurationManager.AppSettings["ServiceNamespace"];
string policyName = ConfigurationManager.AppSettings["SAS_PolicyName"];
string key = ConfigurationManager.AppSettings["SAS_Key"];
try
{
Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", serviceNamespace, string.Empty);
TimeSpan timeSpan = new TimeSpan(480, 30, 30);
TokenScope tokenScope = TokenScope.Namespace;
TokenProvider tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(
policyName,
key,
timeSpan,
tokenScope
);
//NamespaceManager namespaceManager = new NamespaceManager(uri, tokenProvider);
var messagingFactory = MessagingFactory.Create(uri, tokenProvider);
QueueClient qClient = messagingFactory.CreateQueueClient(queueName);
for (int i = 0; i < 5; i++)
{
var msg = GetMessage();
Console.WriteLine(
$"Queued {msg.Value} at {msg.QueuedTime} by {msg.ByPerson}"
);
var brMsg = new BrokeredMessage(msg);
qClient.Send(brMsg);
System.Threading.Thread.Sleep(2500);
}
}
catch (Exception e)
{
throw e;
}
}
private static Uri CreateQueue()
{
string queueName = ConfigurationManager.AppSettings["QueueName"];
try
{
Uri uri = ServiceBusEnvironment.CreateServiceUri("sb", "finomial", string.Empty);
string name = "RootManageSharedAccessKey";
string key = "NZWpkyILur8B4z6djHRFcyzqGR6S7q8iVY1jtTNvzk8=";
TimeSpan timeSpan = new TimeSpan(480, 30, 30);
TokenScope tokenScope = TokenScope.Namespace;
TokenProvider tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(
name, key, timeSpan, tokenScope
);
NamespaceManager namespaceManager = new NamespaceManager(uri, tokenProvider);
//var qs = namespaceManager.GetQueues();
if (!namespaceManager.QueueExists(queueName))
{
QueueDescription queueDesc = new QueueDescription(queueName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(3),
//AutoDeleteOnIdle = TimeSpan.FromHours(1),
MaxSizeInMegabytes = 1024,
LockDuration = TimeSpan.FromMinutes(5),
EnableDeadLetteringOnMessageExpiration = true,
RequiresDuplicateDetection = false
};
namespaceManager.CreateQueue(queueDesc);
}
return(uri);
}
catch (Exception e)
{
throw e;
}
}
public async Task <AuthenticationResult> GetAuthAsync(TargetUri targetUri, TokenScope scope, int requestTimeout, Uri restRootUrl, Credential credentials)
{
// Use the provided username and password and attempt a basic authentication request to a known REST API resource.
var result = await(new RestClient(Context)).TryGetUser(targetUri, requestTimeout, restRootUrl, credentials);
if (result.Type.Equals(AuthenticationResultType.Success))
{
// Success with username/password indicates 2FA is not on so the 'token' is actually
// the password if we had a successful call then the password is good.
var token = new Token(credentials.Password, TokenType.Personal);
if (!string.IsNullOrWhiteSpace(result.RemoteUsername) && !credentials.Username.Equals(result.RemoteUsername))
{
Trace.WriteLine($"remote username [{result.RemoteUsername}] != [{credentials.Username}] supplied username");
return(new AuthenticationResult(AuthenticationResultType.Success, token, result.RemoteUsername));
}
return(new AuthenticationResult(AuthenticationResultType.Success, token));
}
Trace.WriteLine("authentication failed");
return(result);
}
public Style GetStyle(TokenScope scope)
{
switch (scope)
{
case TokenScope.Comment:
return(CommentStyle);
case TokenScope.Keyword:
return(KeywordStyle);
case TokenScope.Preprocessor:
return(PreprocessorStyle);
case TokenScope.String:
return(StringStyle);
case TokenScope.Numeric:
return(NumericStyle);
default:
return(KeywordStyle);
}
}
/// <summary>
/// Construct a TokenProvider based on the provided Key Name and Shared Access Key.
/// </summary>
/// <param name="keyName">The key name of the corresponding SharedAccessKeyAuthorizationRule.</param>
/// <param name="sharedAccessKey">The key associated with the SharedAccessKeyAuthorizationRule</param>
/// <param name="tokenTimeToLive">The token time to live</param>
/// <param name="tokenScope">The tokenScope of tokens to request.</param>
/// <returns>A TokenProvider initialized with the provided RuleId and Password</returns>
public static TokenProvider CreateSharedAccessSignatureTokenProvider(string keyName, string sharedAccessKey, TimeSpan tokenTimeToLive, TokenScope tokenScope)
{
return(new SharedAccessSignatureTokenProvider(keyName, sharedAccessKey, tokenTimeToLive, tokenScope));
}
public TestAzureServiceBusAccountSettings()
{
_tokenTimeToLive = TimeSpan.FromDays(1);
_tokenScope = TokenScope.Namespace;
}
/// <summary> /// Generates a personal access token for use with Azure DevOps. /// <para/> /// Returns the acquired token if successful; otherwise <see langword="null"/>; /// </summary> /// <param name="targetUri">The uniform resource indicator of the resource access tokens are being requested for.</param> /// <param name="accessToken">Access token granted by the identity authority (Azure).</param> /// <param name="tokenScope">The requested access scopes to be granted to the token.</param> /// <param name="requireCompactToken">`<see langword="true"/>` if requesting a compact format token; otherwise `<see langword="false"/>`.</param> public Task <Token> GeneratePersonalAccessToken(TargetUri targetUri, Token accessToken, TokenScope tokenScope, bool requireCompactToken) => GeneratePersonalAccessToken(targetUri, accessToken, tokenScope, requireCompactToken, null);
public BasicAzureServiceBusAccountSettings()
{
_tokenTimeToLive = TimeSpan.FromDays(1);
_tokenScope = TokenScope.Namespace;
}
internal SharedAccessSignatureTokenProvider(string keyName, string sharedAccessKey, TimeSpan tokenTimeToLive, TokenScope tokenScope = TokenScope.Entity)
: this(keyName, sharedAccessKey, MessagingTokenProviderKeyEncoder, tokenTimeToLive, tokenScope)
{
}
private string GetAuthorizationUrl(TokenScope scope)
{
var authorityUrl = $"{AuthorizeUri}?response_type=code&client_id={ConsumerKey}&state=authenticated&scope={scope.ToString()}&redirect_uri={CallbackUri}";
return(new Uri(new Uri("https://bitbucket.org"), authorityUrl).AbsoluteUri);
}
public bool VerifyToken(TokenScope Scope, String token)
{
string Token = ScopeToTokenMap[Scope];
return(token == Token);
}
/// <summary>
/// Generates a personal access token for use with Visual Studio Team Services.
/// <para/>
/// Returns the acquired token if successful; otherwise <see langword="null"/>;
/// </summary>
/// <param name="targetUri">The uniform resource indicator of the resource access tokens are being requested for.</param>
/// <param name="accessToken">Access token granted by the identity authority (Azure).</param>
/// <param name="tokenScope">The requested access scopes to be granted to the token.</param>
/// <param name="requireCompactToken">`<see langword="true"/>` if requesting a compact format token; otherwise `<see langword="false"/>`.</param>
/// <param name="tokenDuration">
/// The requested lifetime of the requested token.
/// <para/>
/// The authority granting the token decides the actual lifetime of any token granted, regardless of the duration requested.
/// </param>
public async Task <Token> GeneratePersonalAccessToken(TargetUri targetUri, Token accessToken, TokenScope tokenScope, bool requireCompactToken, TimeSpan?tokenDuration)
{
return(await Task.FromResult(new Token("personal-access-token", TokenType.Personal)));
}
/// <summary>
/// Construct a TokenProvider based on the provided Key Name and Shared Access Key.
/// </summary>
/// <param name="keyName">The key name of the corresponding SharedAccessKeyAuthorizationRule.</param>
/// <param name="sharedAccessKey">The key associated with the SharedAccessKeyAuthorizationRule</param>
/// <param name="tokenScope">The tokenScope of tokens to request.</param>
/// <returns>A TokenProvider initialized with the provided RuleId and Password</returns>
public static TokenProvider CreateSharedAccessSignatureTokenProvider(string keyName, string sharedAccessKey, TokenScope tokenScope)
{
return(new SharedAccessSignatureTokenProvider(keyName, sharedAccessKey, DefaultTokenTimeout, tokenScope));
}
/// <summary></summary>
/// <param name="tokenScope"></param>
protected TokenProvider(TokenScope tokenScope)
{
this.TokenScope = tokenScope;
this.ThisLock = new object();
}
internal SharedAccessSignatureTokenProvider(string keyName, string sharedAccessKey, TokenScope tokenScope = TokenScope.Entity)
: this(keyName, sharedAccessKey, s_messagingTokenProviderKeyEncoder, s_defaultTokenTimeout, tokenScope)
{
}
/// <summary>
/// Gets the OAuth access token
/// </summary>
/// <returns>The access token</returns>
/// <exception cref="SourceTree.Exceptions.OAuthException">
/// Thrown when OAuth fails for whatever reason
/// </exception>
public async Task <AuthenticationResult> GetAuthAsync(TargetUri targetUri, TokenScope scope, CancellationToken cancellationToken)
{
var authToken = await Authorize(targetUri, scope, cancellationToken);
return(await GetAccessToken(targetUri, authToken));
}