db_filesys/

README

db/mysql/main.go

This Go code is a tool to extract the structure (schema) of a MySQL database and then search it. Here's how it works:

1. Setup:

   • It imports necessary libraries for database interactions (database/sql, MySQL driver) and a custom library (dbminer) for working with the extracted schema.

2. MySQLMiner Structure:

   • A MySQLMiner struct is defined to hold information about the database connection. It includes the database host address (Host) and the database connection object (Db).

3. New Function:

   • The New function creates a new MySQLMiner instance. It takes the database host as input, connects to the database using the connect method, and returns the MySQLMiner object if the connection is successful.

4. Connect Method:

   • The connect method establishes a connection to the MySQL database using provided credentials (root:password). If the connection fails, it logs the error.

5. GetSchema Method:

   • The GetSchema method is the core of the tool. It extracts the schema (structure) of the database.
   • It queries the information_schema database in MySQL to get the list of tables and columns for all databases except system databases (mysql, information_schema, etc.).
   • It iterates over the query results, organizing the information into a structured format (dbminer.Schema). The schema consists of databases, tables within each database, and columns within each table.
   • It returns the structured schema or an error if something goes wrong.

6. Main Function:

   • The main function is the entry point of the program.
   • It gets the database host from the command line argument (os.Args[1]).
   • It creates a MySQLMiner instance (mm) using the provided host.
   • It defers the closing of the database connection (mm.Db.Close()) to ensure proper cleanup.
   • It calls a dbminer.Search function (not shown in the code snippet), which presumably uses the extracted schema to perform searches within the database.

In simple terms:

This tool is like a mapmaker for a city (database). It first figures out the layout of the city, noting down all the districts (databases), streets (tables), and buildings (columns). Then, it uses this map (dbminer.Schema) to help you find specific locations (data) within the city (database) efficiently.

db/mysql-connect/main.go

This Go code is a simple program that reads information from a database of credit card transactions. Here's how it works:

1. Setup:

   • It imports necessary libraries for working with databases (database/sql) and for printing output (fmt).
   • It also includes a MySQL driver (the _ indicates it's imported for its side effects, which is registering the driver).

2. Connect to Database:

   • It connects to a MySQL database named "store" running on the same machine (127.0.0.1). The username is "root" and the password is "password". If the connection fails, it logs the error and panics (stops the program).

3. Retrieve Transaction Data:

   • It prepares a query to select credit card numbers (ccnum), dates (date), amounts (amount), CVV codes (cvv), and expiration dates (exp) from a table named "transactions".
   • It executes the query and gets the results back as rows. If the query fails, it logs the error and panics.

4. Process Transaction Data:

   • It iterates over each row of results.
   • For each row, it reads the values for ccnum, date, amount, cvv, and exp into variables. If there's an error reading the values, it logs the error and panics.
   • It then prints out the values of each transaction (credit card number, date, amount, CVV, expiration date).

5. Error Check:

   • After processing all rows, it checks if there were any errors during the iteration. If so, it logs the error and panics.

6. Clean Up:

   • It closes the database connection (defer db.Close()) to release resources.

In simple terms: Imagine you have a list of credit card transactions written down. This code opens that list, reads each transaction one by one, and shows you the details (card number, date, amount, etc.) on your computer screen.

mongo/main.go

This Go code is a tool designed to explore the structure of a MongoDB database. Think of it like a mapmaker for a new city you've just arrived in. Here's what it does:

1. Setup:

   • It imports necessary libraries:
     • mgo: A library for interacting with MongoDB databases
     • bson: A library for working with MongoDB's data format (BSON)
     • dbminer: A custom library (not shown) likely for analyzing or manipulating database structures.

2. MongoMiner Structure:

   • It defines a MongoMiner structure to hold information about the database connection.
     • Host: The address of the MongoDB server.
     • session: An object representing the connection to the database.

3. New Function:

   • The New function creates a new MongoMiner instance.
   • It takes the database host as input.
   • It attempts to connect to the database using the connect method.
   • If the connection succeeds, it returns the MongoMiner object; otherwise, it returns an error.

4. Connect Method:

   • The connect method establishes the connection to the MongoDB database.

5. GetSchema Method:

   • This is the core of the tool. It extracts the schema (structure) of the MongoDB database.
   • It first gets the names of all the databases on the server.
   • For each database, it gets the names of all the collections (like tables in SQL databases).
   • For each collection, it finds one document (a piece of data) and looks at its fields (like columns in SQL).
   • It stores the database names, collection names, and field names in a structured format called dbminer.Schema.
   • It returns this structured schema, or an error if something goes wrong.

In simple terms:

This tool is like a detective exploring a MongoDB database. It first identifies all the rooms (databases) in the building (the database server). Then, in each room, it checks out some of the objects (documents) to see what kind of information (fields) they contain. Finally, it compiles a report (dbminer.Schema) detailing the structure of the building and its contents.

This information could be used for various purposes, such as:

• Understanding the organization of data in the database
• Generating documentation
• Planning database migrations or changes
• Building tools to query or manipulate the data

db/mongo-connect/main.go

This Go code is designed to retrieve credit card transaction information from a MongoDB database and display it. Here's how it works:

1. Setup:

   • It imports a library (mgo) for working with MongoDB databases.
   • It defines a Transaction struct to represent a credit card transaction. This struct has fields for card number (CCNum), date (Date), amount (Amount), CVV code (Cvv), and expiration date (Expiration).

2. Connect to MongoDB:

   • It establishes a connection to a MongoDB database running on the same machine (localhost). If the connection fails, it logs the error and stops the program.

3. Retrieve Transactions:

   • It retrieves all documents (records) from a collection named "transactions" within a database named "test". These documents are expected to match the structure of the Transaction struct.
   • The results are stored in a slice (a type of list) named results.

4. Display Transactions:

   • It iterates over each transaction in the results slice.
   • For each transaction, it prints out the credit card number, date, amount, CVV, and expiration date.

In simple terms:

This code acts like a clerk fetching a stack of credit card receipts from a filing cabinet (the MongoDB database). The clerk then reads each receipt aloud, announcing the card number, date, amount, and other details.

db/dbminer/dbminer.go

This Go code is designed to find potentially sensitive information (like passwords or credit card numbers) in databases. Here's how it works:

1. DatabaseMiner Interface:

   • Defines a blueprint for a "DatabaseMiner" which can extract the structure (schema) of a database.

2. Schema Structure:

   • Defines a structure to hold the database schema, which includes:
     • Databases: A list of databases.
     • Database: A structure representing a single database with its name and tables.
     • Table: A structure representing a table with its name and columns.

3. Search Function:

   • This is the main function. It takes a DatabaseMiner (something that can extract schemas) as input.
   • It gets the schema from the DatabaseMiner.
   • It creates a list of regular expressions (patterns) to search for sensitive terms like "password", "ssn", "ccnum", etc.
   • It goes through each database, table, and column in the schema.
   • For each column, it checks if the name matches any of the sensitive patterns.
   • If there's a match, it prints out the database and column name where the match was found.

4. getRegex Function:

   • This function simply returns the list of regular expressions used for searching. The patterns are case-insensitive (meaning "password" and "PASSWORD" would both match).

5. String Methods:

   • These methods (String for Schema, Database, and Table) are used to format the schema information in a way that's easy to read when printed out.

In simple terms:

Imagine you're a detective searching a big building (the database) for clues (sensitive information). This code is like a tool that helps you do that. It first figures out the layout of the building (the schema) – which rooms (databases) there are, what furniture (tables) is in each room, and what the furniture is called (columns). Then, it goes through each piece of furniture, checking if the name suggests it might contain something important (like a safe or a file cabinet). If it finds something suspicious, it tells you where to look.

filesystems/main.go

This Go code is designed to find files that might contain sensitive information like usernames, passwords, or login details. Here's how it works:

1. Regular Expressions:

   • It creates a list of patterns (regexes) to search for specific words or parts of words that often appear in sensitive files. These patterns are case-insensitive, meaning they'll match both "password" and "PASSWORD".

2. Walk Function (walkFn):

   • This function is called for each file and folder found while searching.
   • It checks the file or folder's name against each pattern in the list.
   • If there's a match, it prints a message indicating a potential hit, along with the file or folder's path.

3. Main Function:

   • It gets the starting point for the search (the root folder) from the command line argument (the first thing you type after the program's name when you run it).
   • It uses filepath.Walk to go through all files and folders inside the root folder, calling the walkFn function for each one.
   • If there's an error during the walk (like not having permission to access a folder), it logs the error and stops the program.

In simpler terms:

Imagine you're cleaning your room and looking for anything that might have personal information on it (like diaries, bank statements, or sticky notes with passwords). This code is like a robot helper that does the searching for you. You tell it where to start looking (the root folder), and it goes through every item in that area. For each item, it checks if the name sounds like it might be sensitive (using the patterns). If it finds something that looks important, it tells you where it found it.

note - you may need to seed the database with some data to test the code