Difference between revisions of "Fundamentals"

From SkullSecurity
Jump to: navigation, search
(Datatypes)
Line 32: Line 32:
  
 
== Datatypes ==
 
== Datatypes ==
- Bits
+
 
 +
A datatype basically refers to how digits in hex are partitioned off and divided into numbers. Datatypes are typically measures by two factors: the number of bits (or bytes), and whether or not negative numbers are allowed.
 +
 
 +
Although different data lengths are called different things, here are some common ones by their usual name:
 +
 
 +
{|
 +
|+ Datatypes
 +
! Common Name !! Bits !! Bytes !! Hex Range !! Signed Range !! Unsigned Range
 +
|-
 +
! char (or BYTE)
 +
|8 || 1 || 0x00 - 0xFF || -128 - 127 || 0 - 255
 +
|-
 +
! short int (or WORD)
 +
|16 || 2 || 0x0000 - 0xFFFF || -32768 - 32767 || 0 - 65535
 +
|-
 +
! long int (or DWORD, Double WORD)
 +
|32 || 4 || 0x00000000 - 0xFFFFFFFF || -2147483648 - 2147483647 || 0 - 4294967295
 +
|}
 +
 
 +
* 8-bit (1 byte) = char (or BYTE)
 +
** In hex, can be 0x00 to 0xFF
 +
** Signed: ranges from -128 to 127
 +
** Unsigned: ranges from 0 to 255
 +
 
 +
* 16-bit (2 bytes) = short int (often referred to as a WORD)
 +
** In hex, can be 0x0000 to 0xFFFF
 +
** Signed: ranges from -32768 to 32767
 +
** Unsigned: ranges from 0 to 65535
 +
 
 +
* 32-bit (4 bytes) = long int (often referred to as a DWORD or double-WORD)
 +
** In hex, can be 0x00000000 to 0xFFFFFFFF
 +
** Signed: ranges from
 +
* 64-bit (8 bytes) = long long (often referred to as a QWORD or quad-WORD)
  
 
== Memory ==
 
== Memory ==

Revision as of 19:05, 11 March 2007

This page is going to be about the fundamentals that you have to understand before you can make any sense out of assembly. Most of this stuff you'll learn if you learn to program in C. If this is old or boring stuff to you, feel free to skip this section entirely.

The topics here are going to be a short overview of each section. If you want a more complete explanation, you should find an actual reference, or look it up on the Internet. This is only meant to be a quick and dirty primer.

Hexadecimal

To work in assembly, you have to be able to read hexadecimal fairly comfortably. Converting to decimal in your mind isn't necessary, but being able to do some simple arithmetic is.

Hex can be denoted in a number of ways, but the two most common are:

  • Prefixed with a 0x, eg. 0x1ef7
  • Postfixed with a h, eg. 1ef7h

The characters 0 - f represent the decimal numbers 0 - 15:

  • 0 = 0
  • 1 = 1
  • ...
  • 9 = 9
  • a = 10
  • b = 11
  • c = 12
  • d = 13
  • e = 14
  • f = 15

To convert from hex to decimal, multiply each digit, starting with the right-most, with 160, 161, 162, etc. So in the example of 0x1ef7, the conversion is this:

  • (7 * 160) + (f * 161) + (e * 162) + (1 * 163)
  • = (7 * 160) + (15 * 161) + (14 * 162) + (1 * 163)
  • = (7 * 1) + (15 * 16) + (14 * 256) + (1 * 4096)
  • = 7 + 240 + 3584 + 4096
  • = 7927

It isn't necessary to do that constantly, that's why we have calculators. But you should be fairly familiar with the numbers 00 - FF (0 - 255), they will come up often and you will spend a lot of time looking them up.

Datatypes

A datatype basically refers to how digits in hex are partitioned off and divided into numbers. Datatypes are typically measures by two factors: the number of bits (or bytes), and whether or not negative numbers are allowed.

Although different data lengths are called different things, here are some common ones by their usual name:

Datatypes
Common Name Bits Bytes Hex Range Signed Range Unsigned Range
char (or BYTE) 8 1 0x00 - 0xFF -128 - 127 0 - 255
short int (or WORD) 16 2 0x0000 - 0xFFFF -32768 - 32767 0 - 65535
long int (or DWORD, Double WORD) 32 4 0x00000000 - 0xFFFFFFFF -2147483648 - 2147483647 0 - 4294967295
  • 8-bit (1 byte) = char (or BYTE)
    • In hex, can be 0x00 to 0xFF
    • Signed: ranges from -128 to 127
    • Unsigned: ranges from 0 to 255
  • 16-bit (2 bytes) = short int (often referred to as a WORD)
    • In hex, can be 0x0000 to 0xFFFF
    • Signed: ranges from -32768 to 32767
    • Unsigned: ranges from 0 to 65535
  • 32-bit (4 bytes) = long int (often referred to as a DWORD or double-WORD)
    • In hex, can be 0x00000000 to 0xFFFFFFFF
    • Signed: ranges from
  • 64-bit (8 bytes) = long long (often referred to as a QWORD or quad-WORD)

Memory

Pointers

Ascii

Arrays

Strings

Questions

Feel free to edit this section and post questions, I'll do my best to answer them. But you may need to contact me to let me know that a question exists.