Memory Representation

Memory representation is a fundamental concept in programming and computer security that refers to how data is stored in memory. In modern computer systems, memory is divided into small units called bytes, each of which has a unique address.

Programs use these addresses to read and write data in memory. However, the way in which data is represented in memory can have important implications for security and program behavior.

Data Types and Memory Representation

In programming, different data types are used to represent different kinds of data, such as integers, floating-point numbers, and strings. Each data type has a specific size and format, which determines how it is represented in memory. For example, in Python, the int data type is represented using a fixed number of bytes, depending on the platform and version of Python being used.

In Python 3.x, the int type uses a variable-length encoding, which means that the number of bytes used to store an int value can vary depending on its size.

Endianness

Another important aspect of memory representation is endianness, which refers to the order in which bytes are stored in memory. There are two common endianness conventions: little-endian and big-endian.

In little-endian systems, the least significant byte (LSB) of a multi-byte value is stored first, while in big-endian systems, the most significant byte (MSB) is stored first. This can have important implications for binary data formats and network protocols, which must specify an endianness convention to ensure that data is transmitted and interpreted correctly.

In Python, the endianness of the system can be determined using the sys.byteorder attribute. Similarly, in Rust, the endianness of the system can be determined using the byteorder crate, while in C/C++, endianness can be determined using the endian.h header file. Here're some example programs:

# Python program to determine endianness of a system:
import sys

print(sys.byteorder + "endian")

C++:

#include <iostream>
using namespace std;

int main() {
    unsigned int x = 1;
    char *c = (char*)&x;

    if (*c == 1) {
        cout << "Little Endian";
    } else {
        cout << "Big Endian";
    }

    return 0;
}

Rust:

fn main() {
    let num: u16 = 1;
    let little_endian = num.to_le_bytes();
    
    if little_endian[0] == 1 {
        println!("Little Endian");
    } else {
        println!("Big Endian");
    }
}

Memory Safety and Security

Memory representation is also important for security, particularly in systems programming, where programs have direct access to memory and can manipulate it in powerful ways. One important security concern is buffer overflow attacks, which occur when a program writes data past the end of a buffer in memory, overwriting other data or even executing arbitrary code.

To prevent buffer overflow attacks and other memory-related security issues, many programming languages provide memory safety mechanisms, such as bounds checking and type checking. For example, in Rust, the ownership and borrowing system ensures that memory is accessed safely and prevents common memory-related bugs.

In conclusion, memory representation is a fundamental concept in programming and computer security that underlies many aspects of program behavior and security. Understanding how data is stored in memory and how it can be manipulated is essential for writing correct and secure programs and to find potential flaws and exploit them.

Also, here's a table to keep in mind for common units of memory in assembly programming, they're dead useful:

Size	Abbreviation	Description
1 bit	b	A single binary digit
4 bits	nibble	A half byte
8 bits	B or byte	A single byte
16 bits	W or word	Two bytes
32 bits	D or doubleword	Four bytes
64 bits	Q or quadword	Eight bytes
128 bits	O or octword	Sixteen bytes

PS: I'll be refining this section and adding some stuff later if need be 😜