diff --git a/RocketControlUnitGUI/src/lib/hooks/useInteraction.ts b/RocketControlUnitGUI/src/lib/hooks/useInteraction.ts
index 3e9614a..1ac419f 100644
--- a/RocketControlUnitGUI/src/lib/hooks/useInteraction.ts
+++ b/RocketControlUnitGUI/src/lib/hooks/useInteraction.ts
@@ -166,4 +166,4 @@ export const useInteraction = (pocketbaseHook: PocketbaseHook) => {
 		instantStateChange,
 		resumeConfirmRemoveWeight,
 	};
-};
+};
\ No newline at end of file
diff --git a/RocketControlUnitGUI/src/lib/hooks/usePocketbase.ts b/RocketControlUnitGUI/src/lib/hooks/usePocketbase.ts
index f4e3453..833741a 100644
--- a/RocketControlUnitGUI/src/lib/hooks/usePocketbase.ts
+++ b/RocketControlUnitGUI/src/lib/hooks/usePocketbase.ts
@@ -1,20 +1,26 @@
 import PocketBase from 'pocketbase';
 import type { Timestamps } from '../timestamps';
-import type { Stores } from '../stores';
-import { currentState } from '../stores';
+import { currentState, type Stores } from '../stores';
+import { fetchUsbMessage, decryptMessage } from '../message';
 
 export type PocketbaseHook = ReturnType<typeof usePocketbase>;
 
 export const usePocketbase = (timestamps: Timestamps, stores: Stores) => {
-	const pocketbase = new PocketBase('http://192.168.0.69:8090');
+	const pocketbase = new PocketBase('http://localhost:8090');
+
+	const usbMessagePromise = fetchUsbMessage();
 
 	const authenticate = async () => {
-		const email = import.meta.env.VITE_EMAIL;
-		const password = import.meta.env.VITE_PASSWORD;
+		const usbMessage = await usbMessagePromise;
+
+		if (usbMessage) {
+			const { email, password } = usbMessage;
+
+			const decryptedEmail = decryptMessage(email);
+			const decryptedPassword = decryptMessage(password);
 
-		if (email && password) {
 			pocketbase.authStore.clear();
-			await pocketbase.admins.authWithPassword(email, password);
+			await pocketbase.admins.authWithPassword(decryptedEmail, decryptedPassword);
 
 			return true;
 		}
@@ -29,10 +35,18 @@ export const usePocketbase = (timestamps: Timestamps, stores: Stores) => {
 	};
 
 	const writeStateChange = async (state: string) => {
-		await pocketbase.collection('CommandMessage').create({
-			target: 'NODE_DMB',
-			command: state
-		});
+		const usbMessage = await usbMessagePromise;
+
+		if (!usbMessage) {
+			return;
+		}
+
+		if (decryptMessage(usbMessage.permission) == 'MasterKey') {
+			await pocketbase.collection('CommandMessage').create({
+				target: 'NODE_DMB',
+				command: state
+			});
+		}
 	};
 
 	const writeCommandMessage = async (target: string, command: string) => {
diff --git a/RocketControlUnitGUI/src/lib/message.ts b/RocketControlUnitGUI/src/lib/message.ts
new file mode 100644
index 0000000..000ad24
--- /dev/null
+++ b/RocketControlUnitGUI/src/lib/message.ts
@@ -0,0 +1,41 @@
+export function decryptMessage(messageString: string) {
+	let decryptedText = '';
+	let shift = 3;
+
+	if (messageString == 'usb drive not found') {
+		return messageString;
+	}
+
+	for (let char of messageString) {
+		if (/[a-zA-Z]/.test(char)) {
+			const shiftBase = char === char.toUpperCase() ? 'A'.charCodeAt(0) : 'a'.charCodeAt(0);
+			const decryptedChar = String.fromCharCode(
+				((char.charCodeAt(0) - shiftBase - shift + 26) % 26) + shiftBase
+			);
+			decryptedText += decryptedChar;
+		} else {
+			decryptedText += char;
+		}
+	}
+
+	return decryptedText;
+}
+
+export interface UsbData {
+	permission: string;
+	email: string;
+	password: string;
+}
+
+export async function fetchUsbMessage(): Promise<UsbData | undefined> {
+	try {
+		const response = await fetch('http://127.0.0.1:5000/message');
+		if (!response.ok) {
+			throw new Error('Network response was not ok');
+		}
+		const data = await response.json() as UsbData;
+		return data;
+	} catch (error) {
+		console.error('Error:', error);
+	}
+}
\ No newline at end of file
diff --git a/RocketControlUnitGUI/src/routes/+page.svelte b/RocketControlUnitGUI/src/routes/+page.svelte
index 31176b1..4622ca3 100644
--- a/RocketControlUnitGUI/src/routes/+page.svelte
+++ b/RocketControlUnitGUI/src/routes/+page.svelte
@@ -68,6 +68,7 @@
 		timer_remaining
 	} = stores;
 	
+	
 	onMount(() => {
 		let heartbeatInterval: NodeJS.Timeout;
 
@@ -137,6 +138,7 @@
 
 			window.removeEventListener('resize', handleResize);
 		};
+
 	});
 
 	$: ac1_display = $ac1_open === undefined ? 'N/A' : $ac1_open ? 'ON' : 'OFF';
@@ -604,7 +606,7 @@
 	</div>
 
 	<!-- Render different buttons based on the current state -->
-	{#if $currentState == "RS_PRELAUNCH"}
+	{#if $currentState == "RS_PRELAUNCH" } 
 		<button
 			class="btn variant-filled-secondary next-state-btn"
 			style="top: calc(var(--container-width) * 0.5);"
diff --git a/backend/test/dumpy.py b/backend/test/dumpy.py
deleted file mode 100644
index d061021..0000000
--- a/backend/test/dumpy.py
+++ /dev/null
@@ -1,213 +0,0 @@
-import time
-from pocketbase import Client
-import random
-import concurrent.futures
-
-# Initialize PocketBase
-pb = Client("http://127.0.0.1:8090")
-
-battery_data = ["INVALID", "GROUND", "ROCKET"]
-random_bool = lambda: random.choice([True, False])
-random_int = lambda: random.randint(0, 100)
-
-coord_json = {
-    "degrees": random_int(),
-    "minutes": random_int(),
-}
-
-gps_json = {
-    "altitude": random_int(),
-    "unit": random_int(),
-}
-
-
-# Define a function for each table
-def baro_write():
-    pb.collection("Baro").create(
-        {
-            "baro_pressure": random_int(),
-            "baro_temperature": random_int(),
-        }
-    )
-
-
-def battery_write():
-    pb.collection("Battery").create(
-        {
-            "voltage": random_int(),
-            "power_source": random.choice(battery_data),
-        }
-    )
-
-
-def combustion_control_write():
-    pb.collection("CombustionControlStatus").create(
-        {
-            "vent_open": random_int(),
-            "drain_open": random_int(),
-            "mev_open": random_bool(),
-        }
-    )
-
-
-def dmb_pressure_write():
-    pb.collection("DmbPressure").create(
-        {
-            "upper_pv_pressure": random_int(),
-        }
-    )
-
-
-def gps_write():
-    pb.collection("Gps").create(
-        {
-            "latitude": coord_json,
-            "longitude": coord_json,
-            "antenna_altitude": gps_json,
-            "geo_id_altitude": gps_json,
-            "total_altitude": gps_json,
-            "time": random_int(),
-        }
-    )
-
-
-def imu_write():
-    pb.collection("Imu").create(
-        {
-            "accel_x": random_int(),
-            "accel_y": random_int(),
-            "accel_z": random_int(),
-            "gyro_x": random_int(),
-            "gyro_y": random_int(),
-            "gyro_z": random_int(),
-            "mag_x": random_int(),
-            "mag_y": random_int(),
-            "mag_z": random_int(),
-        }
-    )
-
-
-def lr_loadcell_write():
-    pb.collection("LaunchRailLoadCell").create(
-        {
-            "rocket_mass": random_int(),
-        }
-    )
-
-def nos_load_write():
-    pb.collection("NosLoadCell").create(
-        {
-            "nos1_mass": random_int(),
-            "nos2_mass": random_int(),
-        }
-    )
-
-
-def pad_box_write():
-    pb.collection("PadBoxStatus").create(
-        {
-            "continuity_1": random_bool(),
-            "continuity_2": random_bool(),
-            "box1_on": random_bool(),
-            "box2_on": random_bool(),
-        }
-    )
-
-
-def pbb_pressure_write():
-    pb.collection("PbbPressure").create(
-        {
-            "ib_pressure": random_int(),
-            "lower_pv_pressure": random_int(),
-        }
-    )
-
-
-def pbb_temperature_write():
-    pb.collection("PbbTemperature").create(
-        {
-            "ib_temperature": random_int(),
-            "pv_temperature": random_int(),
-        }
-    )
-
-
-def rcu_pressure_write():
-    pb.collection("RcuPressure").create(
-        {
-            "pt1_pressure": random_int(),
-            "pt2_pressure": random_int(),
-            "pt3_pressure": random_int(),
-            "pt4_pressure": random_int(),
-        }
-    )
-
-
-def rcu_temperature_write():
-    pb.collection("RcuTemperature").create(
-        {
-            "tc1_temperature": random_int(),
-            "tc2_temperature": random_int(),
-        }
-    )
-
-
-def relay_status_write():
-    pb.collection("RelayStatus").create(
-        {
-            "ac1_open": random_bool(),
-            "ac2_open": random_bool(),
-            "pbv1_open": random_bool(),
-            "pbv2_open": random_bool(),
-            "pbv3_open": random_bool(),
-            "sol1_open": random_bool(),
-            "sol2_open": random_bool(),
-            "sol3_open": random_bool(),
-            "sol4_open": random_bool(),
-            "sol5_open": random_bool(),
-            "sol6_open": random_bool(),
-            "sol7_open": random_bool(),
-            "sol8a_open": random_bool(),
-            "sol8b_open": random_bool(),
-        }
-    )
-
-
-def sob_temperature_write():
-    pb.collection("SobTemperature").create(
-        {
-            "tc1_temperature": random_int(),
-            "tc2_temperature": random_int(),
-        }
-    )
-
-
-# List of functions
-functions = [
-    baro_write,
-    battery_write,
-    combustion_control_write,
-    dmb_pressure_write,
-    gps_write,
-    imu_write,
-    lr_loadcell_write,
-    nos_load_write,
-    pad_box_write,
-    pbb_pressure_write,
-    pbb_temperature_write,
-    rcu_pressure_write,
-    rcu_temperature_write,
-    relay_status_write,
-    sob_temperature_write,
-]
-
-# Create a ThreadPool
-executor = concurrent.futures.ThreadPoolExecutor(max_workers=20)
-
-# Run all functions every 3 seconds
-while True:
-    # Start a thread for each function
-    for function in functions:
-        executor.submit(function)
-    # Pause for 3 seconds
-    time.sleep(3)
\ No newline at end of file
diff --git a/backend/test/dumpy_reborn.py b/backend/test/dumpy_reborn.py
index 8c12b6e..8a0dc6e 100644
--- a/backend/test/dumpy_reborn.py
+++ b/backend/test/dumpy_reborn.py
@@ -4,8 +4,8 @@
 import concurrent.futures
 
 endpoint = "http://localhost:8090"
-admin_email = "test@test.test"
-admin_password = "123456789a"
+admin_email = "test@test.com"
+admin_password = "0123456789"
 
 # Initialize PocketBase
 pb = PocketBase(endpoint)
@@ -13,9 +13,9 @@
 # Authenticate
 admin_data = pb.admins.auth_with_password(admin_email, admin_password)
 
-if not admin_data.is_valid:
-    print("Authentication failed")
-    exit()
+# if not admin_data.is_valid:
+#     print("Authentication failed")
+#     exit()
 
 battery_data = ["INVALID", "GROUND", "ROCKET"]
 
diff --git a/database/pb_migrations/1732397549_updated_Baro.js b/database/pb_migrations/1732397549_updated_Baro.js
new file mode 100644
index 0000000..3d472ee
--- /dev/null
+++ b/database/pb_migrations/1732397549_updated_Baro.js
@@ -0,0 +1,20 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("2j2bfgv8i8le9vo")
+
+  collection.createRule = ""
+  collection.updateRule = ""
+  collection.deleteRule = ""
+
+  return dao.saveCollection(collection)
+}, (db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("2j2bfgv8i8le9vo")
+
+  collection.createRule = null
+  collection.updateRule = null
+  collection.deleteRule = null
+
+  return dao.saveCollection(collection)
+})
diff --git a/database/pb_migrations/1732397558_updated_Battery.js b/database/pb_migrations/1732397558_updated_Battery.js
new file mode 100644
index 0000000..2aed351
--- /dev/null
+++ b/database/pb_migrations/1732397558_updated_Battery.js
@@ -0,0 +1,20 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("11ezzv9sbk3qspa")
+
+  collection.createRule = ""
+  collection.updateRule = ""
+  collection.deleteRule = ""
+
+  return dao.saveCollection(collection)
+}, (db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("11ezzv9sbk3qspa")
+
+  collection.createRule = null
+  collection.updateRule = null
+  collection.deleteRule = null
+
+  return dao.saveCollection(collection)
+})
diff --git a/database/pb_migrations/1732397611_updated_CombustionControlStatus.js b/database/pb_migrations/1732397611_updated_CombustionControlStatus.js
new file mode 100644
index 0000000..db3ab2f
--- /dev/null
+++ b/database/pb_migrations/1732397611_updated_CombustionControlStatus.js
@@ -0,0 +1,20 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("iem7zt60sts5imk")
+
+  collection.createRule = ""
+  collection.updateRule = ""
+  collection.deleteRule = ""
+
+  return dao.saveCollection(collection)
+}, (db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("iem7zt60sts5imk")
+
+  collection.createRule = null
+  collection.updateRule = null
+  collection.deleteRule = null
+
+  return dao.saveCollection(collection)
+})
diff --git a/database/pb_migrations/1732397618_updated_CommandMessage.js b/database/pb_migrations/1732397618_updated_CommandMessage.js
new file mode 100644
index 0000000..71ab970
--- /dev/null
+++ b/database/pb_migrations/1732397618_updated_CommandMessage.js
@@ -0,0 +1,20 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("s3u9kc1izqjaeds")
+
+  collection.createRule = ""
+  collection.updateRule = ""
+  collection.deleteRule = ""
+
+  return dao.saveCollection(collection)
+}, (db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("s3u9kc1izqjaeds")
+
+  collection.createRule = null
+  collection.updateRule = null
+  collection.deleteRule = null
+
+  return dao.saveCollection(collection)
+})
diff --git a/database/pb_migrations/1732397627_updated_DmbPressure.js b/database/pb_migrations/1732397627_updated_DmbPressure.js
new file mode 100644
index 0000000..03d5867
--- /dev/null
+++ b/database/pb_migrations/1732397627_updated_DmbPressure.js
@@ -0,0 +1,20 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("2oggvjgmpdoytyj")
+
+  collection.createRule = ""
+  collection.updateRule = ""
+  collection.deleteRule = ""
+
+  return dao.saveCollection(collection)
+}, (db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("2oggvjgmpdoytyj")
+
+  collection.createRule = null
+  collection.updateRule = null
+  collection.deleteRule = null
+
+  return dao.saveCollection(collection)
+})
diff --git a/usb-backend/requirements.txt b/usb-backend/requirements.txt
new file mode 100644
index 0000000..9f4d0c0
--- /dev/null
+++ b/usb-backend/requirements.txt
@@ -0,0 +1,2 @@
+Flask
+Flask-Cors
diff --git a/usb-backend/src/state_based_password.py b/usb-backend/src/state_based_password.py
new file mode 100644
index 0000000..61bd3a0
--- /dev/null
+++ b/usb-backend/src/state_based_password.py
@@ -0,0 +1,147 @@
+from flask import Flask, jsonify
+from flask_cors import CORS
+import os
+import platform
+system = platform.uname()
+print(system)
+#local flask server
+app = Flask(__name__)
+
+#allowing 'GET'
+cors = CORS(app, methods=['GET', 'POST'])
+
+usb_name = "MASTER"
+
+#lists usbs in the path provided in the parameter
+def list_files_in_usb(usb_path):
+    try:
+        # Check if the provided path exists
+        if not os.path.exists(usb_path):
+            print(f"The path '{usb_path}' does not exist.")
+            return
+
+        # List all files and directories in the specified USB path
+        for root, dirs, files in os.walk(usb_path):
+            for file in files:
+                if file == "auth.txt":
+                    return file
+                else:
+                    continue
+            else:
+                print("file not found")
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+   
+#This function reads the file at the directory path we gave
+def read_file_from_usb(usb_file_path):
+    try:
+        with open(usb_file_path, 'r') as file:
+            content = file.readlines()  # Read all lines into a list
+            return [line.strip() for line in content]  # Strip whitespace and return as a list
+    except FileNotFoundError:
+        print(f"File not found: {usb_file_path}")
+        return None  # Return None or an empty list if the file is not found
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None  # Return None or an empty list on other exceptions
+    
+#This function encrypts the text in the usb
+def encrypt(text, shift):
+    encrypted_list = []   
+    for word in text:
+        encrypted_text = ""
+        for char in word:
+            if char.isalpha():
+                shift_base = ord('A') if char.isupper() else ord('a')
+                encrypted_char = chr((ord(char) - shift_base + shift) % 26 + shift_base)
+                encrypted_text += encrypted_char
+            else:
+                encrypted_text += char
+        encrypted_list.append(encrypted_text)
+    return encrypted_list
+
+#finds usb for WINDOWS operating systems
+def find_specific_usb(volume_label):
+    os_type = platform.system()
+    
+    if os_type == 'Windows':
+        # Get all drives
+        drives = [f"{chr(d)}:" for d in range(68, 91)]  # D-Z
+        print(drives)
+        for drive in drives:
+            if os.path.exists(drive):
+                # Check the volume label
+                try:
+                    import subprocess
+                    label = subprocess.check_output(f'wmic logicaldisk where "DeviceID=\'{drive}\'" get VolumeName', shell=True).decode().strip().split("\n")[1]
+                    if label.strip() == volume_label:
+                        return drive
+                except Exception as e:
+                    print(f"Error getting volume label: {e}")
+        else:
+            print(f'{volume_label} is not found')
+
+    return None
+#reads file for WINDOWS operating system
+def read_files_from_usb(usb_path):
+    try:
+        for root, dirs, files in os.walk(usb_path):
+            for file in files:
+                file_path = os.path.join(root, file)
+                if file_path.lower().endswith('.txt'):  # Check for text files
+                    print(f"\nReading file: {file_path}")
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        file_content = f.readlines() 
+                        res =[]
+                        for sub in file_content:
+                            res.append(sub.replace("\n", ""))
+                        return res
+    except Exception as e:
+        print(f"Error reading files: {e}")
+
+#sends encrypted message to local host
+@app.route('/message', methods=['GET']) 
+def send():
+    #This checks which os is being used by the user and calls the appropriate function
+    if system[0] == "Darwin":
+        #calls the files listing function
+        try:
+            usb_drive_path ='/Volumes/'+usb_name
+            list_files_in_usb(usb_drive_path)
+            usb_file_path = '/Volumes/'+ usb_name +'/' +  list_files_in_usb(usb_drive_path) # Linux/macOS example
+            password = read_file_from_usb(usb_file_path)
+            key = encrypt(password, 3)
+            return jsonify({'permission': key[0], 'email': key[1], 'password': key[2]})
+        #checks for type error,usb we searched for was not found       
+        except TypeError:
+            return jsonify({'message' : "usb drive not found"})
+            
+    #Checks which us WINDOWS is the os
+    elif system[0] == "Windows":  
+        usb_drive = find_specific_usb(usb_name)
+        print(usb_drive)
+        
+        if usb_drive:
+            password = read_files_from_usb(usb_drive)
+            key = encrypt(password, 3)
+            print(key)
+            return jsonify({'permission': key[0], 'email': key[1], 'password': key[2]})
+        else:
+            return jsonify({'permission' : "usb drive not found"})
+        
+    elif system[0] == "Linux":
+        try:
+            usb_drive_path ='/media/soar/'+usb_name
+            list_files_in_usb(usb_drive_path)
+            usb_file_path = '/media/soar/'+ usb_name +'/' +  list_files_in_usb(usb_drive_path) # Linux/macOS example
+            password = read_file_from_usb(usb_file_path)
+            key = encrypt(password, 3)
+            return jsonify({'permission': key[0], 'email': key[1], 'password': key[2]})
+        #checks for type error,usb we searched for was not found       
+        except TypeError:
+            return jsonify({'message' : "usb drive not found"})
+        
+#runs flask server
+if __name__ == '__main__':
+   app.run()