static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e)
{
if (e.Exception is DirectoryNotFoundException)
{
DirectoryNotFoundException theException = (DirectoryNotFoundException)e.Exception;
BLIO.WriteError(theException, "Folder not found.");
ShowError(e.Exception, e.Exception.GetType().ToString(), theException.Message);
}
if (e.Exception is UnauthorizedAccessException)
{
UnauthorizedAccessException theException = (UnauthorizedAccessException)e.Exception;
BLIO.WriteError(e.Exception, "Unauthorized!");
ShowError(e.Exception, "Unauthorized!", "not authorized for this action.\r\nThis can be resolved by running in administrator-mode.");
}
//Here we just filter out some type of exceptions and give different messages, at the bottom is the super Exception, which can be anything.
else if (e.Exception is FileNotFoundException)
{
FileNotFoundException theException = (FileNotFoundException)e.Exception; //needs in instance to call .FileName
BLIO.WriteError(theException, "converteruld not find the file located at \"" + theException.FileName);
ShowError(e.Exception, "File not found.", "Could not find the file located at \"" + theException.FileName + "\"\r\nHave you moved,renamed or deleted the file?");
}
else if (e.Exception is System.Data.Entity.Core.EntityException)
{
BLIO.WriteError(e.Exception, "System.Data.Entity.Core.EntityException");
ShowError(e.Exception, "System.Data.Entity.Core.EntityException", "There was a problem executing SQL!");
}
else if (e.Exception is ArgumentNullException)
{
BLIO.WriteError(e.Exception, "Null argument");
ShowError(e.Exception, "Null argument", "Null argument exception! Whoops! this is not on your end!");
}
else if (e.Exception is NullReferenceException)
{
BLIO.WriteError(e.Exception, "Null reference");
ShowError(e.Exception, "Null reference", "Null reference exception! Whoops! this is not on your end!");
}
else if (e.Exception is SQLiteException)
{
BLIO.WriteError(e.Exception, "SQLite Database exception");
ShowError(e.Exception, "SQLite Database exception", "encountered a database error!\r\nThis might or might not be on your end. It can be on your end if you modified the database file");
}
else if (e.Exception is PathTooLongException)
{
BLIO.WriteError(e.Exception, "The path to the file is too long.");
ShowError(e.Exception, "File Path too long.", "The path to the file is too long!.");
}
else if (e.Exception is Exception)
{
BLIO.WriteError(e.Exception, "Unknown exception in main.");
}
}
private void MetrocamService_CreateUserCompleted(object sender, RequestCompletedEventArgs e)
{
// Unsubscribe
App.MetrocamService.CreateUserCompleted -= new MobileClientLibrary.RequestCompletedEventHandler(MetrocamService_CreateUserCompleted);
UnauthorizedAccessException err = e.Data as UnauthorizedAccessException;
if (err != null)
{
if (GlobalLoading.Instance.IsLoading)
{
GlobalLoading.Instance.IsLoading = false;
}
// There was an error with CreateUser in the webservice
toastDisplay = GlobalToastPrompt.CreateToastPrompt(
"Signup Failure",
"This Username and/or Email is already being registered to another account.",
3000);
toastDisplay.Show();
return;
}
// Now we authenticate using the username and password
App.MetrocamService.AuthenticateCompleted += new RequestCompletedEventHandler(MetrocamService_AuthenticateCompleted);
// Calls Authenticate to obtain UserInfo object
App.MetrocamService.Authenticate(this.UsernameInput.Text, this.PasswordInput.Password);
}
public async Task ExecuteOperationAsync_UnexpectedExceptionIsWrappedInFatalClientException()
{
var mockPipeline = new Mock <IPipeline>(MockBehavior.Strict);
// some unexpected exception
var innerException = new UnauthorizedAccessException();
mockPipeline
.Setup(h => h.ProcessAsync(
It.IsAny <PipelineContext <BasicTestEntity> >(),
It.IsAny <ILogger>(),
It.IsAny <CancellationToken>()))
.Callback((PipelineContext <BasicTestEntity> context, ILogger log, CancellationToken cancellationToken) => {
throw innerException;
})
.Returns(Task.CompletedTask);
this.mockPipelineFactory
.Setup(h => h.GetPipeline(
It.IsAny <PipelineContext <BasicTestEntity> >()))
.Returns(mockPipeline.Object);
var getContext = new GetContext <BasicTestEntity>(EndpointName.Tests, null);
try
{
await this.apiService.ExecuteOperationAsync(getContext, default).ConfigureAwait(false);
Assert.Fail($"Expected {nameof(FatalClientException)} to be thrown.");
}
catch (FatalClientException e)
{
Assert.IsInstanceOfType(e.InnerException, innerException.GetType());
}
}
private static Exception ToIoException(CodeContext context, string name, UnauthorizedAccessException e)
{
Exception excp = new IOException(e.Message, e);
AddFilename(context, name, excp);
return(excp);
}
private bool SetPolicyFromAuthenticodePrompt(string path, PSHost host, ref Exception reason, Signature signature)
{
bool policyCheckPassed = false;
string reasonMessage;
RunPromptDecision decision = AuthenticodePrompt(path, signature, host);
switch (decision)
{
case RunPromptDecision.RunOnce:
policyCheckPassed = true; break;
case RunPromptDecision.AlwaysRun:
{
TrustPublisher(signature);
policyCheckPassed = true;
}; break;
case RunPromptDecision.DoNotRun:
policyCheckPassed = false;
reasonMessage = StringUtil.Format(Authenticode.Reason_DoNotRun, path);
reason = new UnauthorizedAccessException(reasonMessage);
break;
case RunPromptDecision.NeverRun:
{
UntrustPublisher(signature);
reasonMessage = StringUtil.Format(Authenticode.Reason_NeverRun, path);
reason = new UnauthorizedAccessException(reasonMessage);
policyCheckPassed = false;
}; break;
}
return(policyCheckPassed);
}
public static void AssertSuccess(Win32ErrorCode code)
{
switch (code)
{
case Win32ErrorCode.Success:
case Win32ErrorCode.MORE_DATA:
// No error occured, so exit gracefully.
return;
}
var genericException = new Win32Exception((int)code);
Exception exceptionToThrow;
// We will try to translate the generic Win32 exception to a more specific built-in exception.
switch (code)
{
case Win32ErrorCode.DS_INVALID_DN_SYNTAX:
case Win32ErrorCode.INVALID_PARAMETER:
exceptionToThrow = new ArgumentException(genericException.Message, genericException);
break;
case Win32ErrorCode.FILE_NOT_FOUND:
exceptionToThrow = new FileNotFoundException(genericException.Message, genericException);
break;
case Win32ErrorCode.ACCESS_DENIED:
case Win32ErrorCode.DS_DRA_ACCESS_DENIED:
case Win32ErrorCode.WRONG_PASSWORD:
case Win32ErrorCode.PASSWORD_EXPIRED:
exceptionToThrow = new UnauthorizedAccessException(genericException.Message, genericException);
break;
case Win32ErrorCode.NOT_ENOUGH_MEMORY:
case Win32ErrorCode.OUTOFMEMORY:
case Win32ErrorCode.DS_DRA_OUT_OF_MEM:
case Win32ErrorCode.RPC_S_OUT_OF_RESOURCES:
exceptionToThrow = new OutOfMemoryException(genericException.Message, genericException);
break;
case Win32ErrorCode.NO_LOGON_SERVERS:
case Win32ErrorCode.NO_SUCH_DOMAIN:
case Win32ErrorCode.RPC_S_SERVER_UNAVAILABLE:
case Win32ErrorCode.RPC_S_CALL_FAILED:
exceptionToThrow = new ActiveDirectoryServerDownException(genericException.Message, genericException);
break;
case Win32ErrorCode.DS_OBJ_NOT_FOUND:
// This error code means either a non-existing DN or Access Denied.
case Win32ErrorCode.DS_DRA_BAD_DN:
exceptionToThrow = new DirectoryObjectNotFoundException(null, genericException);
break;
// TODO: Add translation for ActiveDirectoryOperationException and for other exception types.
default:
// We were not able to translate the Win32Exception to a more specific type.
exceptionToThrow = genericException;
break;
}
throw exceptionToThrow;
}
public async Task <Token> RefreshToken(RefreshTokenCredentials refreshTokenCredentials)
{
var unauthorizedException = new UnauthorizedAccessException("Unauthorized token refresh action");
var userRefreshToken = context.RefreshToken.SingleOrDefault(t => t.Token == refreshTokenCredentials.Token && t.UserId == refreshTokenCredentials.UserId);
if (userRefreshToken == null)
{
throw unauthorizedException;
}
var tokenManager = new JwtSecurityTokenHandler();
var token = tokenManager.ReadJwtToken(refreshTokenCredentials.Token);
var tokenUserGuid = token.Claims.Where(c => c.Type == "UserId").Select(c => c.Value).FirstOrDefault();
if (tokenUserGuid == null || tokenUserGuid != refreshTokenCredentials.UserId.ToString())
{
throw unauthorizedException;
}
var user = await userManager.FindByIdAsync(refreshTokenCredentials.UserId.ToString());
if (user == null)
{
throw unauthorizedException;
}
return(GenerateUserToken(user));
}
protected HttpResponseMessage CreateUnauthenticatedMessage(UnauthorizedAccessException ex)
{
var resp = Request.CreateErrorResponse(HttpStatusCode.Unauthorized, ex);
resp.Headers.WwwAuthenticate.Add(new AuthenticationHeaderValue("Basic", "Realm=" + Request.RequestUri.AbsolutePath));
return(resp);
}
internal async Task OnObjectCall(BlockCall request)
{
var reply = new BlockReply {
RequestID = request.RequestID
};
try
{
if (CanCall(request))
{
var resultStream = new MemoryStream();
if (request.ObjectID < 0)
{
OnChannelCall(request, resultStream);
}
else
{
_serviceCache.CallObject(request, resultStream);
}
reply.Success = true;
reply.DataStream = resultStream;
}
else
{
var ex = new UnauthorizedAccessException("Access token error");
reply = BlockReply.BuildFromException(ex, request.RequestID);
}
}
catch (Exception ex)
{
reply = BlockReply.BuildFromException(ex, request.RequestID);
}
await SendBlockAsync(reply);
}
static bool IsExceptionTransient(Exception exception)
{
return(exception switch
{
UnauthorizedAccessException _ => false,
_ => true
});
public async Task <Response> QueryAsync(Type type, string payload)
{
if (!token.HasValue)
{
token.Value = await interop.LoadTokenAsync();
EnsureAuthorization();
}
string url = queryMapper.FindUrlByType(type);
if (url != null)
{
HttpResponseMessage response = await http.PostAsync($"/api/query/{url}", new StringContent(payload, Encoding.UTF8, "text/json"));
if (response.StatusCode == HttpStatusCode.Unauthorized)
{
ClearAuthorization();
UnauthorizedAccessException exception = new UnauthorizedAccessException();
exceptionHandler.Handle(exception);
throw exception;
}
string responseContent = await response.Content.ReadAsStringAsync();
return(SimpleJson.SimpleJson.DeserializeObject <JsResponse>(responseContent));
}
else
{
return(await http.PostJsonAsync <Response>($"/api/query", CreateRequest(type, payload)));
}
}
public void ThrowAnUnauthorizedAccessExceptionWhenAUserIsNotAuthenticated()
{
// GIVEN a UserDTO containing a user's e-mail and password
UserDTO user = new UserDTO
{
EmailAddress = "*****@*****.**",
Password = "******"
};
UnauthorizedAccessException mockException = new UnauthorizedAccessException("Username or password is incorrect.");
// WHEN a user is not correctly authenticated
TrainerCredentials mockTrainerCredentials = new TrainerCredentials
{
EmailAddress = "*****@*****.**",
// NOTE: the hash should be "$2b$10$sCfS.t4SiS21G9rhNcqKue/PkEiitv/OfB0DojqdkMQneiUQw0l06"
Hash = PASSWORD1234_HASH,
Salt = PASSWORD1234_SALT
};
accountContextMock.Setup(a => a.TrainerCredentials.Find(user.EmailAddress)).Returns(mockTrainerCredentials);
// THEN ensure an UnauthorizedAccessException is thrown
UnauthorizedAccessException ex = Assert.Throws <UnauthorizedAccessException>(() => accountServices.AuthorizeTrainer(user));
// AND ensure the message reads "Username or password is incorrect."
Assert.Equal("Username or password is incorrect.", mockException.Message);
}
public async Task Invoke(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception ex)
{
var response = context.Response;
response.ContentType = "application/json";
var responseModel = ApiResponse <string> .Fail(ex.Message);
response.StatusCode = ex switch
{
ApiException e => (int)HttpStatusCode.BadRequest,
KeyNotFoundException e => (int)HttpStatusCode.NotFound,
ArgumentNullException e => (int)HttpStatusCode.NotFound,
UnauthorizedAccessException e => (int)HttpStatusCode.Unauthorized,
_ => (int)HttpStatusCode.InternalServerError
};
var result = JsonSerializer.Serialize(responseModel);
await response.WriteAsync(result);
}
}
}
protected override void LogUnauthorizedAccess(string fullName, UnauthorizedAccessException ex)
{
this.xmlWriter.WriteStartElement("accessDenied");
this.xmlWriter.WriteAttributeString("path", fullName);
this.xmlWriter.WriteAttributeString("message", ex.Message);
this.xmlWriter.WriteEndElement();
}
private static void UnauthorizedAccessExceptionDisplay(UnauthorizedAccessException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine("\n\rHey! It seems you didn't launch this application in administrator!");
Console.WriteLine("Sadly, this is required for the app to work.");
Console.WriteLine("Please launch the application by right-clicking on it and clicking \"Run as Administrator\".\n\r");
}
public async Task RecursePath_GetFiles_OutputException()
{
const string path = "/unAuthorizedPath";
const string expected = "Get Dirs: Write was called";
// Given
var expectedException = new UnauthorizedAccessException(expected);
_fileSystemService.GetFiles(path).Throws(expectedException);
var origOutWriter = Console.Error;
await using (var sw = new StringWriter())
{
Console.SetError(sw);
// When
await _fileWalker.RecursePath(path);
var actual = sw.ToString();
// Then
Assert.Contains(expected, actual);
}
Console.SetError(origOutWriter);
}
public Error Create(IExceptionHandlerFeature contextFeature)
{
Error error = contextFeature.Error switch
{
NotFoundException notFoundException
=> notFoundException.Errors == null
? new NotFoundError(notFoundException.Message)
: new NotFoundError(notFoundException.Message,
new ErrorDetailsCollection(notFoundException.Errors)),
UnauthorizedAccessException unauthorizedAccessException
=> new UnauthorizedAccessError(unauthorizedAccessException.Message),
AppException appException
=> new AppError(appException.Message, new ErrorDetailsCollection(appException.Errors)),
DomainException domainException
=> new DomainError(domainException.Message, new ErrorDetailsCollection(domainException.Errors)),
_
=> new InternalServerError(contextFeature.Error.Message)
};
return(error);
}
}
internal static Exception CreateException(SystemSettingsError err, string msg)
{
Exception exp;
switch (err)
{
case SystemSettingsError.InvalidParameter:
exp = new ArgumentException(msg);
break;
case SystemSettingsError.NotSupported:
exp = new NotSupportedException(msg);
break;
case SystemSettingsError.OutOfMemory:
//fall through
case SystemSettingsError.IoError:
//fall through
case SystemSettingsError.PermissionDenied:
exp = new UnauthorizedAccessException(msg);
break;
case SystemSettingsError.LockScreenAppPasswordMode:
//fall through
default:
exp = new InvalidOperationException(msg);
break;
}
return(exp);
}
private bool SetPolicyFromAuthenticodePrompt(string path, PSHost host, ref Exception reason, System.Management.Automation.Signature signature)
{
string str;
bool flag = false;
switch (this.AuthenticodePrompt(path, signature, host))
{
case RunPromptDecision.NeverRun:
this.UntrustPublisher(signature);
str = StringUtil.Format(Authenticode.Reason_NeverRun, path);
reason = new UnauthorizedAccessException(str);
return(false);
case RunPromptDecision.DoNotRun:
flag = false;
str = StringUtil.Format(Authenticode.Reason_DoNotRun, path);
reason = new UnauthorizedAccessException(str);
return(flag);
case RunPromptDecision.RunOnce:
return(true);
case RunPromptDecision.AlwaysRun:
this.TrustPublisher(signature);
return(true);
}
return(flag);
}
public void AccessDenied()
{
var exception = new UnauthorizedAccessException();
var observedExitCode = ExitCodeUtilities.ShowException(exception);
Assert.Equal((int)ExitCodes.AccessDenied, observedExitCode);
}
public static UnauthorizedAccessException /*!*/ Create(RubyClass /*!*/ self, [DefaultProtocol, DefaultParameterValue(null)] MutableString message)
{
UnauthorizedAccessException result = new UnauthorizedAccessException(RubyExceptions.MakeMessage(ref message, "Permission denied"));
RubyExceptionData.InitializeException(result, message);
return(result);
}
/// <summary>
/// Opens a file with saved data.
/// </summary>
private async Task OpenImpl()
{
var dialogResult = await _fileDialogService.ShowOpenDialogAsync();
if (dialogResult is null)
{
return;
}
try
{
_saveLoadManager.Open(dialogResult);
}
catch (Exception ex)
{
string message = ex switch
{
JsonReaderException _ => "The selected file is not a valid JSON file.",
UnauthorizedAccessException _ =>
"The file cannot be read. Check the permissions on the selected file.",
_ => ex.Message
};
await OpenErrorBox(message);
}
}
// Copy texture from cache
public static bool CopyFileWithRetryOnUnauthorizedAccess(string s, string path)
{
UnauthorizedAccessException exception = null;
for (var k = 0; k < 20; ++k)
{
try
{
File.Copy(s, path, true);
exception = null;
}
catch (UnauthorizedAccessException e)
{
exception = e;
}
}
if (exception != null)
{
Debug.LogException(exception);
// Abort the update, something else is preventing the copy
return(false);
}
return(true);
}
//Handle UnauthorizedAccessException
public static void HandleUnauthorizedAccessException(UnauthorizedAccessException ex)
{
CustomMessageBox.Error(
ex.Message.Contains("The process cannot access the file")
? LangProvider.GetLang("FileIsInUse")
: LangProvider.GetLang("UnauthorizedAccess"), LangProvider.GetLang("ExceptionOccurred"));
}
public static void Permission(UnauthorizedAccessException e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("unauthorised access at this level of permission");
Console.WriteLine(e);
Console.WriteLine("try running the program as admin");
Console.ForegroundColor = ConsoleColor.Gray;
}
public void Erreur_UnauthorizedAccessException_Bien_Traite()
{
UnauthorizedAccessException ex = new UnauthorizedAccessException("UnauthorizedAccessException");
GestionErreur.GerrerErreur(ex);
msbs.Verify(mm => mm.ShowError(AxLanguage.Languages.REAplan_Erreur_Admin + "\n" + AxLanguage.Languages.REAplan_Erreur_Call + "\n" + AxLanguage.Languages.REAplan_Erreur_NumeroTelephone));
log.Verify(ll => ll.Error(ex.GetType().Name + " | " + ex.Message + " |" + ex.StackTrace));
}
protected override async Task HandleChallengeAsync(AuthenticationProperties properties)
{
Response.StatusCode = 401;
Response.ContentType = ProblemDetailsContentType;
var problemDetails = new UnauthorizedAccessException("Unauthorized Access :(");
await Response.WriteAsync(JsonConvert.SerializeObject(problemDetails));
}
public FileSystemAcccesDeniedException(UnauthorizedAccessException ex) : base(null, ex)
{
//"Access to the path 'C:\SoapLogDefaultService\2017-10-31' is denied."
originalMessage = ex.Message;
//never returns null
currentUserName = WindowsIdentity.GetCurrent().Name;
}
protected IActionResult Forbidden <T>(UnauthorizedAccessException ex)
{
var response = new ResponseMessage <T>();
response.AddError(ex);
ControllerContext.HttpContext.Response.StatusCode = StatusCodes.Status403Forbidden;
return(Ok(response));
}
// Third method, UnauthorizedAccessException
public void WriteEventLog(UnauthorizedAccessException ex)
{
EventLog myLog = new EventLog
{
Source = "GoDaddy Update Tool"
};
myLog.WriteEntry(ex.Message, EventLogEntryType.Error);
}
/// <summary>
/// Throws a <see cref="RequestException"/> if the current <see cref=
/// "Response.Message.StatusCode"/> is different than <see cref=
/// "expected"/>.
/// </summary>
/// <param name="expected">
/// The expected <see cref="HttpStatusCode"/>.
/// </param>
/// <returns></returns>
public async Task EnsureStatusCodeAsync(HttpStatusCode expected)
{
var statusCode = this.Message.StatusCode;
if (statusCode == expected)
return;
var details = await Splunk.Client.Message.ReadMessagesAsync(this.XmlReader);
RequestException requestException;
switch (statusCode)
{
case HttpStatusCode.Forbidden:
requestException = new UnauthorizedAccessException(this.Message, details);
break;
case HttpStatusCode.NotFound:
requestException = new ResourceNotFoundException(this.Message, details);
break;
case HttpStatusCode.Unauthorized:
requestException = new AuthenticationFailureException(this.Message, details);
break;
default:
requestException = new RequestException(this.Message, details);
break;
}
throw requestException;
}
/// <summary>
/// Throw request exception asynchronous.
/// </summary>
/// <exception cref="RequestException">
/// Thrown when a Request error condition occurs.
/// </exception>
/// <returns>
/// A <see cref="Task"/> representing the operation.
/// </returns>
internal async Task ThrowRequestExceptionAsync()
{
var details = await Splunk.Client.Message.ReadMessagesAsync(this.XmlReader).ConfigureAwait(false);
RequestException requestException;
switch (this.Message.StatusCode)
{
case HttpStatusCode.BadRequest:
requestException = new BadRequestException(this.Message, details);
break;
case HttpStatusCode.Forbidden:
requestException = new UnauthorizedAccessException(this.Message, details);
break;
case HttpStatusCode.InternalServerError:
requestException = new InternalServerErrorException(this.Message, details);
break;
case HttpStatusCode.NotFound:
requestException = new ResourceNotFoundException(this.Message, details);
break;
case HttpStatusCode.Unauthorized:
requestException = new AuthenticationFailureException(this.Message, details);
break;
default:
requestException = new RequestException(this.Message, details);
break;
}
throw requestException;
}
