Entries Tagged as ''

Windows Fatal Error

The windows fatal error is probably one of the most common errors that we face while working on our computer. Most often than not, you might see these errors on re-starting your computer or when you are trying to shut it down or even when you are trying to start a program in Windows. The fatal error message will look somewhat like this:
“A fatal exception 0E has occurred at 0028 :< XXXXXXXX>”

The Windows fatal error is basically a code, which has been returned by a particular program. This can happen only when:

  • Your computer accesses invalid code or data
  • Your computer has accessed an illegal instruction
  • The privilege level of a particular operation is termed invalid

In any of the above three cases, the processor will return an exception to your computers operating system, which will be seen as a fatal error. In most of the cases, the fatal exception error cannot be recovered and you will have to restart your system or shut it down.

Let us take a deeper look into a fatal error.
An example: “A fatal exception XY has occurred at 0028 :< XXXXXXXX>”

When you see the above fatal error, certain components of the error like XY represents an actual processor exception, which could be anything from 00 to 0F. The <xxxxxxxx> is a value that represents an enhanced instruction pointer to its code segment.

Types of Windows fatal errors

There are several such errors but here are a few of them:

08: Double Fault

This fatal error occurs when during the processing of a particular exception a second exception gets triggered. When this happens, the processor will issue an error message stating that a double fault has taken place.

09: Coprocessor Segment Overrun

This fatal error takes place when a floating point instruction accesses the memory, which runs far beyond the point where the segment ends. Now if the starting point of this floating point is outside the memory segment, then you will see a general protection fault also called interrupt 0D.

00: Divide Fault

The divide fault is a fatal error where the processor will return an exception after encountering the divide fault. This fault will take place if division by zero is attempted.

13 (0Dh): General Protection Fault
This is a common fatal error and it is caused when a particular condition, which is not covered by any processor exception, takes place. When the exception takes place, it means that the memory of the program has become corrupt and will lead to an immediate termination of that particular program.

Troubleshooting a fatal error

The best solution for handling a fatal error is booting your computer and make sure that it is a clean boot.

Buffer Overrun

A buffer overrun calls for a lot of concern because it is considered as one of primary sources that cause security risk. A buffer overrun can occur on any computer and is normally caused when you treat any unchecked data or external input as reliable data. Normally, when you visit the internet and try to open a web page, there are some pages that will show a message stating unreliable data. Most of the times you may click on ok and proceed with the opening of the page because you feel what harm can the data do. This is exactly similar to how a buffer overrun really happens.

When you copy unreliable data using different operations like strcat, CopyMemory, wcscpy or strcpythen it leads to the creation of unanticipated results that further leads to system corruption and you get the buffer overrun error. In some of the cases, an application will automatically abort with a segmentation fault, core dump, or access violation. But when we are talking of the worse case scenario in buffer overrun then it means that an attacker will be able to take advantage of the buffer overrun error and execute their malicious codes into your system process. The most common cause of various exploitable errors or faults is copying of various unchecked input data into the stack-based buffer.

Buffer Overrun Situations

A buffer overrun can take place in different situations and here are some of the situations:

Static buffer overruns

A static buffer overrun takes place when a buffer declared on a stack is introduced to more data than its actual capacity. It can also occur when an unverified user input data gets copied directly to the static variable, which can further lead to a stack corruption.

Heap overruns

Heap overruns is a type of buffer overrun and are quite similar to the static buffer overruns. When a heap overrun occurs, it might cause stack corruption and memory corruption. Heap overruns always take place in heap memory and not on stack memory. Although it might not cause as serious a problem as stack buffer overruns can cause yet it is recommended that they need real programming care, which might mitigate the potential risks.

Array indexing errors

The array indexing errors cause memory overruns. They cause a different type of buffer overrun as compared to the static and heap overrun errors. The only way to prevent this error is through careful index management.

The only way to prevent a buffer overrun is by writing a good code. Whenever it comes to the code, ensure that you have validated all your inputs. It is important to always maintain a high degree of correct programming for the safety of the memory and stack on your PC.

Driver Errors

Driver errors are not uncommon and you will find some when you are installing/uninstalling a particular program. Drivers are basically a type of software program that enables an operating system as well as the different programs that are installed on them to effectively communicate with different hardware devices, device controllers, as well as peripherals that are connected to your PC. You can say that drivers are like instruction manuals that provide the different software’s located on your PC with the right information regarding control and enhances communication with various hardware devices.

Dealing with driver errors

There is a huge database of drivers on all computers and it might become difficult and even impossible at times to keep track of the drivers you have on your computer. So if driver errors do occur, it might be difficult for you to correct it at time. There are several reasons that can be attributed to causing the driver errors. Let us take a look at some of the possible driver errors and their probable solutions:

Problem 1

Device has not been properly connected to your PC
The Solution: In such a scenario, if you get driver errors then you need to check the cables connecting the particular device to your computer. Check for any loose connection. If the device is a card then open your cabinet and check if the card is in the right slot and has been properly seated.

Problem 2

You see driver errors showing failed device driver. Such a problem will occur only when:

  • The driver installed by you is buggy
  • The driver has been poorly designed
  • The driver is incompatible with your OS
  • Problems occurred during a driver update
  • There is a hardware conflict

The easiest solutions for the above mentioned problems are two fold: Either find a driver update or find a replacement driver. In either case, when you download or run them then the driver errors will stop showing up. Sometimes, updating a specific component within the driver can also resolve the issue and enhance the performance of your computer. The best place to look for driver updates, new drivers and options for troubleshooting driver errors is the manufacturer’s website. One more thing that you need to check always while downloading a new driver is the Operating System specifics. Drivers are available these days on the basis on the Windows OS being used by you. You can’t download and run a driver specified for Win98 on a WinXP computer.

In Windows XP, you can fix most of the driver errors by visiting the Device Manager utility, which will provide you all information regarding the various devices configured on your PC.