diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..cb447c4
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,9 @@
+.DS_Store
+.gradle
+build
+src/test/resources/changed.xlsx
+testServer/**/*.xls*
+./*.xlsx
+./*.xls
+TODO.md
+.idea
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..cf2101a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,104 @@
+# Sheet Intruder
+```
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡤⠐⠢⠀⠀⠀⠀⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡠⠉⠀⠀⠀⠱⠀⠀⠀⠀⠀
+⠀⠀⠀⣀⣀⣤⣤⣤⣶⣶⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣮⣑⠡⡀⡀⠀⢀⡇⠀⠀⠀⠀
+⢰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⢰⣶⣶⣶⣶⣶⣶⣶⣶⣶⡄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠⣿⣄⠈⣌⠪⡄⢰⢡⠀⠀⠀⠀
+⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠈⠉⠉⣿⣿⡟⠉⠉⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⢿⣾⣀⠈⢂⠃⡈⠘⣄⠀⠀⠀
+⢸⣿⣿⣏⠉⠙⣿⣿⠉⠉⣿⣿⣿⠀⠀⢠⣤⣤⣿⣿⣧⣤⣤⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢘⣿⣷⣄⠤⢢⠁⡠⠂⠢⡀⠀
+⢸⣿⣿⣿⣆⠀⠸⠃⢀⣾⣿⣿⣿⠀⠀⠸⠿⠿⣿⣿⡿⠿⠿⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠏⣸⡿⠟⣾⠓⠉⡖⠀⠀⠈⢂
+⢸⣿⣿⣿⣿⠆⠀⠀⢾⣿⣿⣿⣿⠀⠀⠀⠀⠀⣿⣿⡇⠀⠀⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣆⡏⢸⠟⠀⣾⠀⠈⢡⡠⠂⠀⠈
+⢸⣿⣿⣿⠏⠀⣰⡄⠀⢿⣿⣿⣿⠀⠀⢰⣶⣶⣿⣿⣷⣶⣶⣿⣿⡇⠀⠀⠀⣦⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡼⡀⡇⢈⠐⠠⡟⠀⠀⢞⡿⢅⠄⢀
+⢸⣿⣿⣃⣀⣰⣿⣷⣀⣀⣻⣿⣿⠀⠀⠘⠛⠛⣿⣿⡟⠛⠛⣿⣿⡇⠀⠀⠀⠹⣿⣷⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠜⠊⢛⡃⠘⠀⠀⡇⠀⡈⠶⠄⠒⠂⡔
+⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⢀⣀⣀⣿⣿⣧⣀⣀⣿⣿⡇⠀⠀⠀⠀⠘⣿⣿⣿⣷⣄⣀⠀⠤⡠⡤⠒⠫⠱⠀⣼⠧⠀⠀⠀⢁⠠⢱⠤⠒⠒⣠⠇
+⠸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠸⠿⠿⠿⠿⠿⠿⠿⠿⠿⠃⠀⠀⠀⠀⠀⠘⢿⣿⣿⣿⣾⡷⡋⣞⠔⡣⠎⠙⠂⠘⠒⠲⡖⡒⠒⡶⢙⠀⠈⠉⣸⠀
+⠀⠀⠀⠉⠉⠛⠛⠛⠿⠿⣿⣿⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠻⣿⣿⡿⣿⣿⣯⠪⡖⠤⠤⠔⣀⣤⡃⠀⠀⡁⠀⣀⠄⠊⡜⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠛⢿⡌⠙⢿⣾⡫⠅⠂⠉⠀⠀⠁⠪⢁⠈⠉⠀⠀⣸⠀⠀
+⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠙⠚⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⠀⠀⠉⠀⠀
+```
+
+
+_Make Excel Fuzzing Simpler_
+
+## Introduction
+
+Sheet Intruder is a Burp Suite extension designed to simplify the process of fuzzing for Excel file uploads.
+It works by representing the content of an Excel file as a tag, which can then be integrated into various locations.
+This tag then allows configuration such as replacements for fuzzing targets.
+
+## Features
+
+- Seamless Integration: Sheet Intruder seamlessly integrates into Burp Suite's Intruder, Scanner, and Repeater tools,
+  allowing for efficient and comprehensive Excel file manipulation during different stages of testing.
+
+- Both .xls and .xlsx file formats are supported
+
+- Value Replacement Mode: Use the `<$SheetIntruder>` tag to define value replacements within the Excel file. This
+  mode allows you to search for specific values within cells and replace them with desired substitutions.
+
+- Cell Replacement Mode: Use the `<$SheetIntruderCell>` tag to perform cell-based replacements. You can replace cells
+  either by referencing their cell number (e.g., "A1", "B1") or by specifying cell ranges (e.g., "A1:B12", "CustomSheet!
+  A1:D5").
+
+## Workflow
+
+1. Choose your Excel file (.xls and .xlsx supported)
+2. The selected file is loaded into the extension
+3. In Repeater, Proxy, Scanner or Intruder you are now able to include the tags described below
+4. Before sending the request the provided Excel file is read and the requested modifications made
+
+### Value Replacement Mode Tag
+This mode searches for specific values within cells and replaces them with the desired substitutions in the Excel file.
+
+```
+<$SheetIntruder>
+{
+    "valueToReplace": "replacement",
+    "valueToReplace2": "replacement2"
+}
+</$SheetIntruder>
+```
+
+
+### Cell Replacement Mode Tag
+This mode replaces cells referenced by their cell number with the given substitution.
+Examples:
+
+```
+<$SheetIntruderCell>
+{
+   "A1": "replacement",
+   "B1": "replacement2"
+}
+</$SheetIntruderCell>
+
+<$SheetIntruderCell>
+{
+   "A1": "replacement",
+   "CustomSheet!B21": "otherSheetB21"
+}
+</$SheetIntruderCell>
+
+<$SheetIntruderCell>
+{
+   "A1:B12": "rangeReplacement",
+   "CustomSheet!A1:D5": "otherSheetRange"
+}
+</$SheetIntruderCell>
+
+```
+
+--- 
+
+### Building from source
+```
+$ gradle build shadowJar
+```
+
+### Testing
+A test server is provided and can be built using the docker file. It's only purpose is to simulate a file upload,
+and store the uploaded files for diagnostics.
+```bash
+$ docker build -t sheetintruder-testserver:latest .
+$ docker run -p 5000:5000 -v $(pwd):/output sheetintruder-testserver
+```
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000..17a706f
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,36 @@
+plugins {
+    id 'com.github.johnrengelman.shadow' version '7.1.2'
+    id 'java'
+}
+
+
+group 'ch.redguard'
+version '1.0.0'
+
+repositories {
+    mavenLocal()
+    mavenCentral()
+}
+
+dependencies {
+    // https://mvnrepository.com/artifact/com.google.code.gson/gson
+    implementation group: 'com.google.code.gson', name: 'gson', version: '2.10.1'
+
+    compileOnly 'net.portswigger.burp.extensions:montoya-api:2023.10.3'
+    testImplementation 'net.portswigger.burp.extensions:montoya-api:2023.10.3'
+
+    implementation('org.apache.poi:poi:5.2.4')
+    implementation('org.apache.poi:poi-ooxml:5.2.4')
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
+}
+
+shadowJar {
+    mergeServiceFiles()
+    archiveClassifier = 'all'
+}
+
+test {
+    useJUnitPlatform()
+}
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..249e583
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..ae04661
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100755
index 0000000..a69d9cb
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,240 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruder.java b/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruder.java
new file mode 100644
index 0000000..49a98a5
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruder.java
@@ -0,0 +1,41 @@
+package ch.redguard.burp.sheet_intruder;
+
+import burp.api.montoya.BurpExtension;
+import burp.api.montoya.MontoyaApi;
+import burp.api.montoya.extension.Extension;
+import burp.api.montoya.logging.Logging;
+import ch.redguard.burp.sheet_intruder.ui.MainPanel;
+
+import javax.swing.*;
+
+public class SheetIntruder implements BurpExtension {
+    @Override
+    public void initialize(MontoyaApi api) {
+        Extension extension = api.extension();
+        extension.setName("Sheet Intruder");
+        extension.registerUnloadingHandler(new SheetIntruderUnloadingHandler());
+        Logging logging = api.logging();
+        logging.logToOutput("Sheet Intruder loading...");
+
+        var uiPanel = new MainPanel();
+
+        var pane = new JTabbedPane();
+        pane.addTab("Select Excel", uiPanel);
+
+        var registration = api.userInterface().registerSuiteTab("Sheet Intruder", pane);
+        api.logging().raiseDebugEvent("Registered tab: " + registration.isRegistered());
+
+        var handlerRegistration =
+                api.http().registerHttpHandler(new SheetIntruderHttpHandler(api.utilities().byteUtils(),
+                        api.logging()));
+        logging.logToOutput("Registering HTTP Handler: " + handlerRegistration.isRegistered());
+
+        var contextMenuRegistration =
+                api.userInterface().registerContextMenuItemsProvider(new SheetIntruderMenuItemsProvider(api.utilities().byteUtils(), api.logging()));
+        logging.logToOutput("Registering Context Menu Handler: " + contextMenuRegistration.isRegistered());
+
+        logging.logToOutput("Sheet Intruder loaded");
+    }
+
+
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruderHttpHandler.java b/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruderHttpHandler.java
new file mode 100644
index 0000000..a4643b0
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruderHttpHandler.java
@@ -0,0 +1,77 @@
+package ch.redguard.burp.sheet_intruder;
+
+import burp.api.montoya.core.ByteArray;
+import burp.api.montoya.http.handler.HttpRequestToBeSent;
+import burp.api.montoya.http.handler.HttpResponseReceived;
+import burp.api.montoya.http.handler.RequestToBeSentAction;
+import burp.api.montoya.http.handler.ResponseReceivedAction;
+import burp.api.montoya.http.message.requests.HttpRequest;
+import burp.api.montoya.logging.Logging;
+import burp.api.montoya.utilities.ByteUtils;
+import ch.redguard.burp.sheet_intruder.parser.JsonParser;
+import ch.redguard.burp.sheet_intruder.parser.ParsedTag;
+import ch.redguard.burp.sheet_intruder.parser.Replacer;
+import ch.redguard.burp.sheet_intruder.parser.TagByteParser;
+import ch.redguard.burp.sheet_intruder.ui.SelectedFile;
+
+import java.io.File;
+import java.util.Optional;
+
+
+public class SheetIntruderHttpHandler implements burp.api.montoya.http.handler.HttpHandler {
+
+    private final ByteUtils byteUtils;
+    private final Logging logging;
+
+    SheetIntruderHttpHandler(ByteUtils byteUtils, Logging logging) {
+        this.byteUtils = byteUtils;
+        this.logging = logging;
+    }
+
+    @Override
+    public RequestToBeSentAction handleHttpRequestToBeSent(HttpRequestToBeSent requestToBeSent) {
+        HttpRequest newRequest = requestToBeSent;
+        switch (requestToBeSent.toolSource().toolType()) {
+            case SCANNER, INTRUDER, REPEATER, PROXY -> {
+                var body = requestToBeSent.body().getBytes();
+                var tagByteParser = new TagByteParser(body, byteUtils, logging);
+                ParsedTag parsedTag = tagByteParser.getTagContent();
+
+                if (parsedTag.isEmptyOrInvalid()) {
+                    logging.raiseDebugEvent("No valid tag found, not modifying request");
+                    break;
+                }
+
+                var replacements = new JsonParser(parsedTag.getContent(), logging).parseJson();
+                if (replacements.isEmpty()) {
+                    logging.raiseDebugEvent("No valid json found, not modifying request");
+                    break;
+                }
+                logging.raiseDebugEvent("Found replacement config " + replacements);
+
+                Optional<File> selectedFile = SelectedFile.getInstance().getFile();
+
+                if (selectedFile.isEmpty()) {
+                    logging.raiseDebugEvent("No file configured, not modifying request");
+                    break;
+                }
+
+                logging.raiseDebugEvent("Using configured file " + selectedFile.get().getPath());
+
+                var newBody =
+                        new Replacer(body, replacements, parsedTag, selectedFile.get(), logging).getReplacedBody();
+                if (newBody.isPresent()) {
+                    newRequest = requestToBeSent.withBody(ByteArray.byteArray(newBody.get()));
+                }
+            }
+            default -> {
+            }
+        }
+        return RequestToBeSentAction.continueWith(newRequest);
+    }
+
+    @Override
+    public ResponseReceivedAction handleHttpResponseReceived(HttpResponseReceived responseReceived) {
+        return ResponseReceivedAction.continueWith(responseReceived);
+    }
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruderMenuItemsProvider.java b/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruderMenuItemsProvider.java
new file mode 100644
index 0000000..f808acb
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruderMenuItemsProvider.java
@@ -0,0 +1,92 @@
+package ch.redguard.burp.sheet_intruder;
+
+import burp.api.montoya.core.ByteArray;
+import burp.api.montoya.http.message.requests.HttpRequest;
+import burp.api.montoya.logging.Logging;
+import burp.api.montoya.ui.contextmenu.ContextMenuEvent;
+import burp.api.montoya.ui.contextmenu.ContextMenuItemsProvider;
+import burp.api.montoya.ui.contextmenu.MessageEditorHttpRequestResponse;
+import burp.api.montoya.utilities.ByteUtils;
+import ch.redguard.burp.sheet_intruder.tag.TagType;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionListener;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+public class SheetIntruderMenuItemsProvider implements ContextMenuItemsProvider {
+
+    private final ByteUtils byteUtils;
+    private final Logging logging;
+
+    public SheetIntruderMenuItemsProvider(ByteUtils byteUtils, Logging logging) {
+        this.byteUtils = byteUtils;
+        this.logging = logging;
+    }
+
+    @Override
+    public List<Component> provideMenuItems(ContextMenuEvent event) {
+        switch (event.invocationType()) {
+            case INTRUDER_PAYLOAD_POSITIONS:
+            case MESSAGE_EDITOR_REQUEST:
+            case MESSAGE_VIEWER_RESPONSE:
+                break;
+            default:
+                return null;
+        }
+
+        logging.raiseDebugEvent("Context is in right mode, will add tags");
+
+        final JMenuItem valueModeTag = new JMenuItem("Value Mode Tag");
+        valueModeTag.addActionListener(generateTagActionListener(event, TagType.VALUE_TAG));
+
+        final JMenuItem cellModeTag = new JMenuItem("Cell Mode Tag");
+        cellModeTag.addActionListener(generateTagActionListener(event, TagType.CELL_TAG));
+
+        return List.of(valueModeTag, cellModeTag);
+    }
+
+    ActionListener generateTagActionListener(final ContextMenuEvent event, TagType tagType) {
+        return e -> event.messageEditorRequestResponse().ifPresent(m -> {
+            logging.raiseDebugEvent("Generating context menu action listener for " + tagType.getStartTag());
+            logging.raiseDebugEvent("m.selectionContext() " + m.selectionContext());
+
+            if (m.selectionContext() == MessageEditorHttpRequestResponse.SelectionContext.REQUEST) {
+                HttpRequest request = m.requestResponse().request();
+                var requestBytes = request.toByteArray().getBytes();
+                var caretPosition = m.caretPosition() + 2;
+
+                addTagToPosition(requestBytes, request.bodyOffset(), caretPosition, tagType).ifPresent(newBody ->
+                        m.setRequest(request.withBody(ByteArray.byteArray(newBody)))
+                );
+            }
+        });
+    }
+
+    Optional<byte[]> addTagToPosition(byte[] requestBytes, int bodyOffset, int caretPosition, TagType tagType) {
+        byte[] tagStart = this.byteUtils.convertFromString(tagType.getStartTag());
+        byte[] tagEnd = this.byteUtils.convertFromString(tagType.getEndTag());
+        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
+            outputStream.write(Arrays.copyOfRange(requestBytes, 0, caretPosition));
+
+            outputStream.write(tagStart);
+            outputStream.write(tagEnd);
+
+            outputStream.write(Arrays.copyOfRange(requestBytes, caretPosition, requestBytes.length));
+
+            outputStream.flush();
+            var fullRequest = outputStream.toByteArray();
+            var onlyBody = Arrays.copyOfRange(fullRequest, bodyOffset, fullRequest.length);
+
+            return Optional.of(onlyBody);
+        } catch (RuntimeException | IOException e1) {
+            logging.logToError("Could not create context action listener: " + e1.getMessage());
+        }
+        return Optional.empty();
+    }
+}
+
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruderUnloadingHandler.java b/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruderUnloadingHandler.java
new file mode 100644
index 0000000..59f6c90
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/SheetIntruderUnloadingHandler.java
@@ -0,0 +1,11 @@
+package ch.redguard.burp.sheet_intruder;
+
+import burp.api.montoya.extension.ExtensionUnloadingHandler;
+import ch.redguard.burp.sheet_intruder.ui.SelectedFile;
+
+public class SheetIntruderUnloadingHandler implements ExtensionUnloadingHandler {
+    @Override
+    public void extensionUnloaded() {
+        SelectedFile.getInstance().unloadFile();
+    }
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/excel/ExcelParser.java b/src/main/java/ch/redguard/burp/sheet_intruder/excel/ExcelParser.java
new file mode 100644
index 0000000..ad253f7
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/excel/ExcelParser.java
@@ -0,0 +1,146 @@
+package ch.redguard.burp.sheet_intruder.excel;
+
+import burp.api.montoya.logging.Logging;
+import ch.redguard.burp.sheet_intruder.parser.IParser;
+import ch.redguard.burp.sheet_intruder.parser.Mode;
+import org.apache.poi.ss.usermodel.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.Optional;
+
+public class ExcelParser implements IParser {
+    private final File file;
+    private final Logging logging;
+
+    public ExcelParser(File file, Logging logging) {
+        this.file = file;
+        this.logging = logging;
+    }
+
+    private static void replaceValues(Map<String, String> replacements, Row row) {
+        for (Cell cell : row) {
+            if (cell.getCellType() == CellType.STRING) {
+                String cellValue = cell.getStringCellValue();
+                for (Map.Entry<String, String> entry : replacements.entrySet()) {
+                    if (cellValue.contains(entry.getKey())) {
+                        cellValue = cellValue.replace(entry.getKey(), entry.getValue());
+                        cell.setCellValue(cellValue);
+                    }
+                }
+            }
+        }
+    }
+
+    public static Validity getValidity(File file) {
+        try (var ignored = WorkbookFactory.create(file)) {
+            return new Validity(true, "");
+        } catch (Exception e) {
+            return new Validity(false, e.getMessage());
+        }
+    }
+
+    public Optional<byte[]> readAndReplace(Map<String, String> replacements, Mode mode) {
+        logging.raiseDebugEvent("Reading file " + file.getName() + " from config and applying replacements. Mode: " + mode.name());
+        try (FileInputStream fileInputStream = new FileInputStream(file); Workbook workbook =
+                WorkbookFactory.create(fileInputStream)) {
+            workbook.setForceFormulaRecalculation(true);
+            if (mode == Mode.CELL) {
+                replaceCells(replacements, workbook);
+            } else {
+                for (int i = 0; i < workbook.getNumberOfSheets(); i++) {
+                    Sheet sheet = workbook.getSheetAt(i);
+
+                    for (Row row : sheet) {
+                        replaceValues(replacements, row);
+                    }
+                }
+            }
+            var byteOutput = new ByteArrayOutputStream();
+            workbook.write(byteOutput);
+            workbook.close();
+            byteOutput.close();
+            return Optional.of(byteOutput.toByteArray());
+        } catch (IOException e) {
+            logging.raiseErrorEvent("An error occurred while reading the excel file: " + e.getMessage());
+        }
+        logging.raiseDebugEvent("No excel file content found, no replacements made!");
+        return Optional.empty();
+    }
+
+    private void replaceCells(Map<String, String> replacements, Workbook workbook) throws IOException {
+        for (Map.Entry<String, String> entry : replacements.entrySet()) {
+            String cellReference = entry.getKey();
+            int exclamationIndex = cellReference.indexOf("!");
+            Sheet targetSheet;
+            if (exclamationIndex == -1) {
+                targetSheet = workbook.getSheetAt(0);
+            } else {
+                String sheetName = cellReference.substring(0, exclamationIndex);
+                targetSheet = workbook.getSheet(sheetName);
+                cellReference = cellReference.substring(exclamationIndex + 1);
+            }
+            if (targetSheet == null) {
+                throw new IOException("Configured sheet not found");
+            }
+
+            if (cellReference.contains(":")) {
+                replaceRange(cellReference, entry.getValue(), targetSheet);
+            } else {
+                replaceCell(cellReference, entry.getValue(), targetSheet);
+            }
+        }
+    }
+
+    private void replaceCell(String cellReference, String value, Sheet targetSheet) {
+        int columnIndex = getColumnIndex(cellReference);
+        int rowIndex = Integer.parseInt(cellReference.replaceAll("[A-Za-z]", "")) - 1;
+        Row targetRow = targetSheet.getRow(rowIndex);
+        if (targetRow == null) {
+            targetRow = targetSheet.createRow(rowIndex);
+        }
+        Cell cell = targetRow.getCell(columnIndex);
+        if (cell == null) {
+            cell = targetRow.createCell(columnIndex);
+        }
+        cell.setCellValue(value);
+    }
+
+    private void replaceRange(String cellRange, String value, Sheet targetSheet) {
+        String[] cellReferences = cellRange.split(":");
+        String startCellReference = cellReferences[0];
+        String endCellReference = cellReferences[1];
+
+        int startRowIndex = Integer.parseInt(startCellReference.replaceAll("[A-Za-z]", "")) - 1;
+        int endRowIndex = Integer.parseInt(endCellReference.replaceAll("[A-Za-z]", "")) - 1;
+        int startColumnIndex = getColumnIndex(startCellReference);
+        int endColumnIndex = getColumnIndex(endCellReference);
+
+        for (int rowIndex = startRowIndex; rowIndex <= endRowIndex; rowIndex++) {
+            Row targetRow = targetSheet.getRow(rowIndex);
+            if (targetRow == null) {
+                targetRow = targetSheet.createRow(rowIndex);
+            }
+            for (int columnIndex = startColumnIndex; columnIndex <= endColumnIndex; columnIndex++) {
+                Cell cell = targetRow.getCell(columnIndex);
+                if (cell == null) {
+                    cell = targetRow.createCell(columnIndex);
+                }
+                cell.setCellValue(value);
+            }
+        }
+    }
+
+    private int getColumnIndex(String cellReference) {
+        String columnReference = cellReference.replaceAll("[0-9]", "");
+        int columnIndex = -1;
+        for (int i = 0; i < columnReference.length(); i++) {
+            columnIndex = (columnIndex + 1) * 26 + columnReference.charAt(i) - 'A';
+        }
+        return columnIndex;
+    }
+}
+
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/excel/Validity.java b/src/main/java/ch/redguard/burp/sheet_intruder/excel/Validity.java
new file mode 100644
index 0000000..bc9d96b
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/excel/Validity.java
@@ -0,0 +1,20 @@
+package ch.redguard.burp.sheet_intruder.excel;
+
+public class Validity {
+    private final boolean valid;
+    private final String reason;
+
+    Validity(boolean valid, String reason) {
+        this.valid = valid;
+        this.reason = reason;
+    }
+
+    public final boolean isValid() {
+        return valid;
+    }
+
+    public final String getReason() {
+        return reason;
+    }
+
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/parser/IParser.java b/src/main/java/ch/redguard/burp/sheet_intruder/parser/IParser.java
new file mode 100644
index 0000000..c048eab
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/parser/IParser.java
@@ -0,0 +1,8 @@
+package ch.redguard.burp.sheet_intruder.parser;
+
+import java.util.Map;
+import java.util.Optional;
+
+public interface IParser {
+    Optional<byte[]> readAndReplace(Map<String, String> replacements, Mode mode);
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/parser/JsonParser.java b/src/main/java/ch/redguard/burp/sheet_intruder/parser/JsonParser.java
new file mode 100644
index 0000000..59661b8
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/parser/JsonParser.java
@@ -0,0 +1,41 @@
+package ch.redguard.burp.sheet_intruder.parser;
+
+import burp.api.montoya.logging.Logging;
+import com.google.gson.Gson;
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+
+import java.io.StringReader;
+import java.lang.reflect.Type;
+import java.util.Map;
+
+public class JsonParser {
+    private final byte[] tagContent;
+    private final Logging logging;
+
+    public JsonParser(byte[] tagContent, Logging logging) {
+        this.tagContent = tagContent;
+        this.logging = logging;
+    }
+
+    public final Map<String, String> parseJson() {
+        Gson gson = new Gson();
+        String jsonString = new String(tagContent).trim();
+
+        Type mapType = new TypeToken<Map<String, String>>() {
+        }.getType();
+
+        JsonReader reader = new JsonReader(new StringReader(jsonString));
+        reader.setLenient(true);
+
+        try {
+            return gson.fromJson(reader, mapType);
+        } catch (JsonSyntaxException e) {
+            logging.logToError("Invalid json in tag configuration: " + e.getMessage());
+            return Map.of();
+        }
+
+
+    }
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/parser/Mode.java b/src/main/java/ch/redguard/burp/sheet_intruder/parser/Mode.java
new file mode 100644
index 0000000..50e1a24
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/parser/Mode.java
@@ -0,0 +1,10 @@
+package ch.redguard.burp.sheet_intruder.parser;
+
+public enum Mode {
+    DEFAULT(),
+    CELL();
+
+    Mode() {
+    }
+
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/parser/ParsedTag.java b/src/main/java/ch/redguard/burp/sheet_intruder/parser/ParsedTag.java
new file mode 100644
index 0000000..e758ae9
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/parser/ParsedTag.java
@@ -0,0 +1,40 @@
+package ch.redguard.burp.sheet_intruder.parser;
+
+public class ParsedTag {
+    private final byte[] content;
+    private final Mode mode;
+    private int startIndex;
+    private int endIndex;
+
+    ParsedTag(byte[] content, Mode mode, int startIndex, int endIndex) {
+        this.content = content;
+        this.mode = mode;
+        this.startIndex = startIndex;
+        this.endIndex = endIndex;
+    }
+
+    ParsedTag() {
+        this.content = new byte[0];
+        this.mode = Mode.DEFAULT;
+    }
+
+    public byte[] getContent() {
+        return content;
+    }
+
+    public Mode getMode() {
+        return mode;
+    }
+
+    public boolean isEmptyOrInvalid() {
+        return this.content.length == 0;
+    }
+
+    public int getStartIndex() {
+        return startIndex;
+    }
+
+    public int getEndIndex() {
+        return endIndex;
+    }
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/parser/Replacer.java b/src/main/java/ch/redguard/burp/sheet_intruder/parser/Replacer.java
new file mode 100644
index 0000000..357a556
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/parser/Replacer.java
@@ -0,0 +1,56 @@
+package ch.redguard.burp.sheet_intruder.parser;
+
+import burp.api.montoya.logging.Logging;
+import ch.redguard.burp.sheet_intruder.excel.ExcelParser;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
+public class Replacer {
+    private final byte[] body;
+    private final Map<String, String> replacements;
+    private final File file;
+    private final Logging logging;
+    private final ParsedTag parsedTag;
+
+    public Replacer(byte[] body, Map<String, String> replacements, ParsedTag parsedTag, File file, Logging logging) {
+        this.body = body;
+        this.replacements = replacements;
+        this.parsedTag = parsedTag;
+        this.file = file;
+        this.logging = logging;
+    }
+
+    public static byte[] concat(byte[]... arrays) {
+        int len = Arrays.stream(arrays).filter(Objects::nonNull)
+                .mapToInt(s -> s.length).sum();
+
+        byte[] result = new byte[len];
+        int lengthSoFar = 0;
+
+        for (byte[] array : arrays) {
+            if (array != null) {
+                System.arraycopy(array, 0, result, lengthSoFar, array.length);
+                lengthSoFar += array.length;
+            }
+        }
+
+        return result;
+    }
+
+    public Optional<byte[]> getReplacedBody() {
+        var excelBytes = new ExcelParser(file, logging).readAndReplace(replacements, parsedTag.getMode());
+        return excelBytes.map(bytes -> {
+            logging.raiseDebugEvent("Replacing strings in file '" + file.getName() + "' with replacements '" + replacements + "'");
+            var tagStartIndex = parsedTag.getStartIndex();
+            var tagEndIndex = parsedTag.getEndIndex();
+            var beforeBytes = Arrays.copyOfRange(body, 0, tagStartIndex);
+            var afterBytes = Arrays.copyOfRange(body, tagEndIndex, body.length);
+            return concat(beforeBytes, bytes, afterBytes);
+        });
+    }
+
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/parser/TagByteParser.java b/src/main/java/ch/redguard/burp/sheet_intruder/parser/TagByteParser.java
new file mode 100644
index 0000000..fbf4880
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/parser/TagByteParser.java
@@ -0,0 +1,73 @@
+package ch.redguard.burp.sheet_intruder.parser;
+
+import burp.api.montoya.logging.Logging;
+import burp.api.montoya.utilities.ByteUtils;
+import ch.redguard.burp.sheet_intruder.tag.TagType;
+
+import java.util.Arrays;
+
+public class TagByteParser {
+    private final byte[] body;
+    private final ByteUtils byteUtils;
+    private final Logging logging;
+
+    public TagByteParser(byte[] body, ByteUtils byteUtils, Logging logging) {
+        this.body = body;
+        this.byteUtils = byteUtils;
+        this.logging = logging;
+    }
+
+    public ParsedTag getTagContent() {
+        if (hasTag(body)) {
+            logging.raiseDebugEvent("Found tag content, will process");
+            return getBytesBetweenTags(body);
+        }
+        return new ParsedTag();
+    }
+
+    private ParsedTag getBytesBetweenTags(byte[] inputArray) {
+        Mode mode = Mode.DEFAULT;
+        String startTag, endTag;
+        int startIndex, endIndex;
+        startTag = TagType.VALUE_TAG.getStartTag();
+        endTag = TagType.VALUE_TAG.getEndTag();
+        startIndex = byteUtils.indexOf(inputArray, byteUtils.convertFromString(startTag), false);
+        endIndex = byteUtils.indexOf(inputArray, byteUtils.convertFromString(endTag), false);
+        if (startIndex == -1 || endIndex == -1) {
+            startTag = TagType.CELL_TAG.getStartTag();
+            endTag = TagType.CELL_TAG.getEndTag();
+            startIndex = byteUtils.indexOf(inputArray, byteUtils.convertFromString(startTag), false);
+            endIndex = byteUtils.indexOf(inputArray, byteUtils.convertFromString(endTag), false);
+            if (startIndex == -1 || endIndex == -1) {
+                return new ParsedTag(
+                        new byte[0],
+                        mode,
+                        startIndex,
+                        endIndex + endTag.length()
+                );
+            }
+            mode = Mode.CELL;
+        }
+        return new ParsedTag(
+                Arrays.copyOfRange(inputArray, startIndex + startTag.length(), endIndex),
+                mode,
+                startIndex,
+                endIndex + endTag.length()
+        );
+    }
+
+
+    private boolean hasTag(byte[] body) {
+        //IMPROVE: handle multiple tags
+        return (byteUtils.indexOf(
+                body,
+                byteUtils.convertFromString(TagType.VALUE_TAG.getStartTag()),
+                false
+        ) > -1) || (byteUtils.indexOf(
+                body,
+                byteUtils.convertFromString(TagType.CELL_TAG.getStartTag()),
+                false
+        ) > -1);
+    }
+
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/tag/TagType.java b/src/main/java/ch/redguard/burp/sheet_intruder/tag/TagType.java
new file mode 100644
index 0000000..99e7b90
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/tag/TagType.java
@@ -0,0 +1,30 @@
+package ch.redguard.burp.sheet_intruder.tag;
+
+import ch.redguard.burp.sheet_intruder.parser.Mode;
+
+public enum TagType {
+    VALUE_TAG("<$SheetIntruder>", "</$SheetIntruder>", Mode.DEFAULT),
+    CELL_TAG("<$SheetIntruderCell>", "</$SheetIntruderCell>", Mode.CELL);
+
+    private final String startTag;
+    private final String endTag;
+    private final Mode mode;
+
+    TagType(String startTag, String endTag, Mode mode) {
+        this.startTag = startTag;
+        this.endTag = endTag;
+        this.mode = mode;
+    }
+
+    public String getStartTag() {
+        return startTag;
+    }
+
+    public String getEndTag() {
+        return endTag;
+    }
+
+    public Mode getMode() {
+        return mode;
+    }
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/ui/JMultilineLabel.java b/src/main/java/ch/redguard/burp/sheet_intruder/ui/JMultilineLabel.java
new file mode 100644
index 0000000..38c1fb8
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/ui/JMultilineLabel.java
@@ -0,0 +1,23 @@
+package ch.redguard.burp.sheet_intruder.ui;
+
+import javax.swing.*;
+import javax.swing.border.EmptyBorder;
+import java.io.Serial;
+
+public class JMultilineLabel extends JTextArea {
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    public JMultilineLabel(String text) {
+        super(text);
+        setEditable(false);
+        setCursor(null);
+        setOpaque(false);
+        setFocusable(false);
+        setFont(UIManager.getFont("Label.font"));
+        setWrapStyleWord(true);
+        setLineWrap(true);
+        setBorder(new EmptyBorder(5, 5, 5, 5));
+        setAlignmentY(JLabel.CENTER_ALIGNMENT);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/ui/MainPanel.java b/src/main/java/ch/redguard/burp/sheet_intruder/ui/MainPanel.java
new file mode 100644
index 0000000..cea231b
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/ui/MainPanel.java
@@ -0,0 +1,194 @@
+package ch.redguard.burp.sheet_intruder.ui;
+
+import ch.redguard.burp.sheet_intruder.excel.ExcelParser;
+import ch.redguard.burp.sheet_intruder.tag.TagType;
+
+import javax.swing.*;
+import javax.swing.filechooser.FileFilter;
+import java.awt.*;
+import java.io.File;
+
+public class MainPanel extends JPanel {
+
+    public MainPanel() {
+        this.setLayout(new GridBagLayout());
+
+        JLabel headerLabel = new JLabel("Sheet Intruder");
+        Font font = this.getFont().deriveFont(32f).deriveFont(this.getFont().getStyle() | Font.BOLD);
+        headerLabel.setFont(font);
+
+        JLabel subtitle = new JLabel("Make Excel Fuzzing Simpler");
+        Font subtitleFont = subtitle.getFont().deriveFont(16f).deriveFont(subtitle.getFont().getStyle() | Font.ITALIC);
+        subtitle.setFont(subtitleFont);
+
+        JSeparator separator = new JSeparator(SwingConstants.HORIZONTAL);
+        separator.setBorder(BorderFactory.createEmptyBorder(15, 0, 15, 0));
+
+        var browseButton = new JButton("Choose Excel File...");
+        var fileNameTextField = new JTextField();
+
+        var statusLabel = new JLabel();
+        browseButton.addActionListener(actionEvent -> browseFiles(this, fileNameTextField, statusLabel));
+
+        var reloadFileButton = new JButton("Reload file");
+        reloadFileButton.addActionListener(actionEvent -> loadFile(statusLabel, new File(fileNameTextField.getText())));
+
+        JLabel howToLabel = new JLabel("How To");
+        howToLabel.setFont(this.getFont().deriveFont(20f).deriveFont(this.getFont().getStyle() | Font.BOLD));
+
+
+        var howTo = new JMultilineLabel("""
+                   1. Choose your Excel file (.xls and .xlsx supported) above
+                   2. The selected file is loaded into the extension
+                   3. In Repeater, Proxy, Scanner or Intruder you are now able to include the tags described below
+                   4. Before sending the request the provided excel is read and the requested modifications made
+                """);
+
+        var valueReplaceMode = new JLabel("Value Replacement Mode Tag");
+        valueReplaceMode.setFont(this.getFont().deriveFont(16f).deriveFont(this.getFont().getStyle() | Font.BOLD));
+
+        var replaceMode = new JTextArea("""
+                <START>
+                {
+                    "valueToReplace": "replacement",
+                    "valueToReplace2": "replacement2"
+                }
+                <END>
+                """.replace("<START>", TagType.VALUE_TAG.getStartTag())
+                .replace("<END>", TagType.VALUE_TAG.getEndTag())
+        );
+
+
+        replaceMode.setEditable(false);
+        replaceMode.setBorder(BorderFactory.createEtchedBorder());
+
+        var howTo2 = new JMultilineLabel("Search for values in cells and replace in the provided Excel file with the " +
+                "desired substitution");
+        var cellReplacementMode = new JLabel("Cell Replacement Mode Tag");
+        cellReplacementMode.setFont(this.getFont().deriveFont(16f).deriveFont(this.getFont().getStyle() | Font.BOLD));
+
+
+        var cellMode = new JTextArea("""
+                <START>
+                {
+                   "A1": "replacement",
+                   "B1": "replacement2"
+                }
+                <END>
+
+                <START>
+                {
+                   "A1": "replacement",
+                   "CustomSheet!B21": "otherSheetB21"
+                }
+                <END>
+                                
+                <START>
+                {
+                   "A1:B12": "rangeReplacement",
+                   "CustomSheet!A1:D5": "otherSheetRange"
+                }
+                <END>
+                """.replace("<START>", TagType.CELL_TAG.getStartTag())
+                .replace("<END>", TagType.CELL_TAG.getEndTag())
+        );
+
+        var howTo3 = new JMultilineLabel("""
+                Replace cells referenced by their cell number with the given substitution
+                """);
+
+        cellMode.setEditable(false);
+        cellMode.setBorder(BorderFactory.createEtchedBorder());
+
+
+        this.add(headerLabel, getConstraints(0, 0, 2, 1));
+        this.add(subtitle, getConstraints(0, 1, 2, 1));
+        this.add(separator, getConstraints(0, 2, 2, 1));
+
+        this.add(browseButton, getConstraints(0, 3, 1, 0.1f));
+        this.add(fileNameTextField, getConstraints(1, 3, 1, 0.8f));
+        this.add(reloadFileButton, getConstraints(2, 3, 1, 0.1f));
+
+        this.add(statusLabel, getConstraints(0, 4, 2, 1));
+        this.add(howToLabel, getConstraints(0, 5, 2, 1, new Insets(10, 10, 5, 0)));
+        this.add(howTo, getConstraints(0, 6, 2, 1));
+        this.add(valueReplaceMode, getConstraints(0, 7, 2, 1, new Insets(10, 10, 5, 0)));
+        this.add(replaceMode, getConstraints(0, 8, 2, 1, new Insets(10, 25, 0, 0)));
+        this.add(howTo2, getConstraints(0, 9, 2, 1));
+        this.add(cellReplacementMode, getConstraints(0, 10, 2, 1, new Insets(10, 10, 5, 0)));
+        this.add(cellMode, getConstraints(0, 11, 2, 1, new Insets(10, 25, 0, 0)));
+        this.add(howTo3, getConstraints(0, 12, 2, 1));
+
+
+        addBottomPadding();
+    }
+
+    private void addBottomPadding() {
+        GridBagConstraints c = new GridBagConstraints();
+        c.fill = GridBagConstraints.HORIZONTAL;
+
+        JSeparator bottomSeparator = new JSeparator(SwingConstants.HORIZONTAL);
+        c.ipady = 0;
+        c.weighty = 1.0;
+        c.anchor = GridBagConstraints.PAGE_END;
+        c.insets = new Insets(10, 0, 0, 0);
+        c.gridx = 0;
+        c.gridwidth = 2;
+        c.gridy = 13;
+        this.add(bottomSeparator, c);
+    }
+
+    private GridBagConstraints getConstraints(int x, int y, int width, float weightx) {
+        Insets insets = new Insets(0, 10, 0, 0);
+
+        return this.getConstraints(x, y, width, weightx, insets);
+    }
+
+    private GridBagConstraints getConstraints(int x, int y, int width, float weightx, Insets insets) {
+        var gbc = new GridBagConstraints();
+        gbc.gridx = x;
+        gbc.gridy = y;
+        gbc.gridwidth = width;
+        gbc.anchor = GridBagConstraints.WEST;
+        gbc.weightx = weightx;
+        gbc.fill = GridBagConstraints.HORIZONTAL;
+        gbc.insets = insets;
+        return gbc;
+    }
+
+
+    private void browseFiles(Component panel, JTextField fileNameTextField, JLabel statusLabel) {
+        var jfc = new JFileChooser(fileNameTextField.getText());
+        jfc.setFileFilter(new FileFilter() {
+            @Override
+            public boolean accept(File file) {
+                return file.isDirectory() || file.getName().endsWith(".xlsx") || file.getName().endsWith(".xls");
+            }
+
+            @Override
+            public String getDescription() {
+                return "Excel Files (.xls, .xlsx)";
+            }
+        });
+        jfc.setDialogTitle("Select Excel File");
+        int status = jfc.showOpenDialog(panel);
+        statusLabel.setText("No file loaded");
+        if (status == JFileChooser.APPROVE_OPTION) {
+            File selectedFile = jfc.getSelectedFile();
+            fileNameTextField.setText(selectedFile.getPath());
+            loadFile(statusLabel, selectedFile);
+        }
+    }
+
+    private void loadFile(JLabel statusLabel, File selectedFile) {
+        statusLabel.setText("Loading File...");
+        var validity = ExcelParser.getValidity(selectedFile);
+        if (validity.isValid()) {
+            SelectedFile.getInstance().setFile(selectedFile);
+            statusLabel.setText("File '" + selectedFile.getName() + "' (" + selectedFile.length() + " bytes) loaded");
+        } else {
+            statusLabel.setText("Error: File is not a valid excel file: " + validity.getReason());
+        }
+    }
+
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/ui/SelectedFile.java b/src/main/java/ch/redguard/burp/sheet_intruder/ui/SelectedFile.java
new file mode 100644
index 0000000..ab9c238
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/ui/SelectedFile.java
@@ -0,0 +1,33 @@
+package ch.redguard.burp.sheet_intruder.ui;
+
+import java.io.File;
+import java.util.Optional;
+
+public class SelectedFile {
+    private static SelectedFile instance;
+    private Optional<File> file;
+
+    private SelectedFile() {
+    }
+
+    public static SelectedFile getInstance() {
+        if (instance == null) {
+            instance = new SelectedFile();
+        }
+        return instance;
+    }
+
+
+    public Optional<File> getFile() {
+        return file;
+    }
+
+    public void setFile(File file) {
+        this.file = Optional.of(file);
+    }
+
+    public void unloadFile() {
+        this.file = Optional.empty();
+    }
+
+}
diff --git a/src/main/java/ch/redguard/burp/sheet_intruder/ui/SheetIntruderAction.java b/src/main/java/ch/redguard/burp/sheet_intruder/ui/SheetIntruderAction.java
new file mode 100644
index 0000000..4bdb840
--- /dev/null
+++ b/src/main/java/ch/redguard/burp/sheet_intruder/ui/SheetIntruderAction.java
@@ -0,0 +1,26 @@
+package ch.redguard.burp.sheet_intruder.ui;
+
+import burp.api.montoya.ui.contextmenu.ContextMenuEvent;
+import ch.redguard.burp.sheet_intruder.parser.Mode;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+
+public class SheetIntruderAction extends AbstractAction {
+    private final Mode mode;
+    private final ContextMenuEvent event;
+
+    public SheetIntruderAction(String text, Mode mode, ContextMenuEvent event) {
+        super(text);
+        this.mode = mode;
+        this.event = event;
+    }
+
+
+    @Override
+    public void actionPerformed(ActionEvent actionEvent) {
+
+    }
+
+
+}
diff --git a/src/test/java/ch/redguard/burp/sheet_intruder/SheetIntruderMenuItemsProviderTest.java b/src/test/java/ch/redguard/burp/sheet_intruder/SheetIntruderMenuItemsProviderTest.java
new file mode 100644
index 0000000..54deb48
--- /dev/null
+++ b/src/test/java/ch/redguard/burp/sheet_intruder/SheetIntruderMenuItemsProviderTest.java
@@ -0,0 +1,26 @@
+package ch.redguard.burp.sheet_intruder;
+
+import ch.redguard.burp.sheet_intruder.mock.TestByteUtils;
+import ch.redguard.burp.sheet_intruder.tag.TagType;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class SheetIntruderMenuItemsProviderTest {
+
+    @Test
+    void addTagToPosition() {
+        var provider = new SheetIntruderMenuItemsProvider(new TestByteUtils(), new TestLogging());
+
+        byte[] body = "before_after".getBytes();
+        int position = 6;
+
+        Optional<byte[]> resultBody = provider.addTagToPosition(body, 0, position, TagType.CELL_TAG);
+        assertEquals(
+                "before" + TagType.CELL_TAG.getStartTag() + TagType.CELL_TAG.getEndTag() + "_after",
+                new String(resultBody.get())
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/ch/redguard/burp/sheet_intruder/TestLogging.java b/src/test/java/ch/redguard/burp/sheet_intruder/TestLogging.java
new file mode 100644
index 0000000..0b3b32a
--- /dev/null
+++ b/src/test/java/ch/redguard/burp/sheet_intruder/TestLogging.java
@@ -0,0 +1,59 @@
+package ch.redguard.burp.sheet_intruder;
+
+import burp.api.montoya.logging.Logging;
+
+import java.io.PrintStream;
+
+public class TestLogging implements Logging {
+
+    @Override
+    public PrintStream output() {
+        return System.out;
+    }
+
+    @Override
+    public PrintStream error() {
+        return System.err;
+    }
+
+    @Override
+    public void logToOutput(String message) {
+        System.out.println(message);
+    }
+
+    @Override
+    public void logToError(String message) {
+        System.err.println(message);
+    }
+
+    @Override
+    public void logToError(String message, Throwable cause) {
+        logToError(message);
+        logToError(cause.getMessage());
+    }
+
+    @Override
+    public void logToError(Throwable cause) {
+        logToError(cause.getMessage());
+    }
+
+    @Override
+    public void raiseDebugEvent(String message) {
+        logToOutput(message);
+    }
+
+    @Override
+    public void raiseInfoEvent(String message) {
+        logToOutput(message);
+    }
+
+    @Override
+    public void raiseErrorEvent(String message) {
+        logToError(message);
+    }
+
+    @Override
+    public void raiseCriticalEvent(String message) {
+        logToError(message);
+    }
+}
diff --git a/src/test/java/ch/redguard/burp/sheet_intruder/TestUI.java b/src/test/java/ch/redguard/burp/sheet_intruder/TestUI.java
new file mode 100644
index 0000000..402aa68
--- /dev/null
+++ b/src/test/java/ch/redguard/burp/sheet_intruder/TestUI.java
@@ -0,0 +1,27 @@
+package ch.redguard.burp.sheet_intruder;
+
+import ch.redguard.burp.sheet_intruder.ui.MainPanel;
+
+import javax.swing.*;
+import java.awt.*;
+
+public class TestUI {
+
+    public static void main(String[] args) {
+        JFrame jFrame = new JFrame("Burp Suite - Sheet Intruder");
+        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        jFrame.setLayout(new BorderLayout());
+
+        jFrame.setPreferredSize(new Dimension(1500, 800));
+        JMenuBar menuBar = new JMenuBar();
+        jFrame.setJMenuBar(menuBar);
+        jFrame.pack();
+        var uiPanel = new MainPanel();
+
+        Container content = jFrame.getContentPane();
+        content.setLayout(new BorderLayout());
+
+        content.add(uiPanel, BorderLayout.WEST);
+        jFrame.setVisible(true);
+    }
+}
diff --git a/src/test/java/ch/redguard/burp/sheet_intruder/TestUtil.java b/src/test/java/ch/redguard/burp/sheet_intruder/TestUtil.java
new file mode 100644
index 0000000..a958b93
--- /dev/null
+++ b/src/test/java/ch/redguard/burp/sheet_intruder/TestUtil.java
@@ -0,0 +1,15 @@
+package ch.redguard.burp.sheet_intruder;
+
+import java.io.File;
+
+public class TestUtil {
+    public static File getXlsxFile() {
+        return new File("src/test/resources/Book1.xlsx");
+    }
+
+
+    public static File getXlsFile() {
+        return new File("src/test/resources/Book1.xls");
+    }
+
+}
diff --git a/src/test/java/ch/redguard/burp/sheet_intruder/excel/ExcelParserTest.java b/src/test/java/ch/redguard/burp/sheet_intruder/excel/ExcelParserTest.java
new file mode 100644
index 0000000..31c4856
--- /dev/null
+++ b/src/test/java/ch/redguard/burp/sheet_intruder/excel/ExcelParserTest.java
@@ -0,0 +1,171 @@
+package ch.redguard.burp.sheet_intruder.excel;
+
+import ch.redguard.burp.sheet_intruder.TestLogging;
+import ch.redguard.burp.sheet_intruder.TestUtil;
+import ch.redguard.burp.sheet_intruder.parser.Mode;
+import org.apache.poi.ss.usermodel.*;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+class ExcelParserTest {
+    @Test
+    void readAndReplace() throws IOException {
+        var logging = new TestLogging();
+        var parser = new ExcelParser(TestUtil.getXlsxFile(), logging);
+        var replacedBytes = parser.readAndReplace(Map.of(
+                "valueToReplace", "replacement",
+                "valueToReplace2", "replacement2"
+        ), Mode.DEFAULT).get();
+
+        try (ByteArrayInputStream bis = new ByteArrayInputStream(replacedBytes)) {
+            Workbook workbook = new XSSFWorkbook(bis);
+            try (FileOutputStream fis = new FileOutputStream("src/test/resources/changed.xlsx")) {
+                workbook.write(fis);
+            }
+        }
+
+        var cellValues = getAllCellValues(replacedBytes);
+        var frequency = cellValues.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+
+        assertEquals(2, frequency.get("replacement"));
+        assertEquals(2, frequency.get("replacement2"));
+    }
+
+    @Test
+    void testXls() throws IOException {
+        var logging = new TestLogging();
+        var parser = new ExcelParser(TestUtil.getXlsFile(), logging);
+        var replacedBytes = parser.readAndReplace(Map.of(
+                "valueToReplace", "replacement",
+                "valueToReplace2", "replacement2"
+        ), Mode.DEFAULT).get();
+
+        var cellValues = getAllCellValues(replacedBytes);
+        var frequency = cellValues.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
+
+        assertEquals(2, frequency.get("replacement"));
+        assertEquals(2, frequency.get("replacement2"));
+    }
+
+    @Test
+    void testCellMode() throws IOException {
+        var logging = new TestLogging();
+        var parser = new ExcelParser(TestUtil.getXlsFile(), logging);
+        var excelBytes = parser.readAndReplace(Map.of(
+                "A1", "A1Replaced",
+                "B12", "B12Replaced"
+        ), Mode.CELL).get();
+
+        ByteArrayInputStream bis = new ByteArrayInputStream(excelBytes);
+        Workbook workbook = WorkbookFactory.create(bis);
+        var sheet = workbook.getSheetAt(0);
+        assertEquals("A1Replaced", sheet.getRow(0).getCell(0).getStringCellValue());
+        assertEquals("B12Replaced", sheet.getRow(11).getCell(1).getStringCellValue());
+    }
+
+    @Test
+    void testCellModeWithSheet() throws IOException {
+        var logging = new TestLogging();
+        var parser = new ExcelParser(TestUtil.getXlsFile(), logging);
+        var excelBytes = parser.readAndReplace(Map.of(
+                "A1", "A1Replaced",
+                "CustomSheet!B21", "otherSheetB21"
+        ), Mode.CELL).get();
+
+        ByteArrayInputStream bis = new ByteArrayInputStream(excelBytes);
+        Workbook workbook = WorkbookFactory.create(bis);
+        var sheet = workbook.getSheetAt(0);
+        assertEquals("A1Replaced", sheet.getRow(0).getCell(0).getStringCellValue());
+
+        var otherSheet = workbook.getSheet("CustomSheet");
+        assertEquals("otherSheetB21", otherSheet.getRow(21 - 1).getCell(1).getStringCellValue());
+
+        assertEquals("shouldStay", sheet.getRow(21 - 1).getCell(1).getStringCellValue());
+    }
+
+    @Test
+    void testCellModeWithRanges() throws IOException {
+        var logging = new TestLogging();
+        var parser = new ExcelParser(TestUtil.getXlsFile(), logging);
+        var excelBytes = parser.readAndReplace(Map.of(
+                "A1:D5", "replacement"
+        ), Mode.CELL).get();
+
+        ByteArrayInputStream bis = new ByteArrayInputStream(excelBytes);
+        Workbook workbook = WorkbookFactory.create(bis);
+        var sheet = workbook.getSheetAt(0);
+
+        for (int rowNum = 0; rowNum < 4; rowNum++) {
+            for (int cellNum = 0; cellNum < 4; cellNum++) {
+                assertEquals("replacement", sheet.getRow(rowNum).getCell(cellNum).getStringCellValue());
+            }
+        }
+    }
+
+    @Test
+    void testCellModeWithRangeOtherSheet() throws IOException {
+        var logging = new TestLogging();
+        var parser = new ExcelParser(TestUtil.getXlsFile(), logging);
+        var excelBytes = parser.readAndReplace(Map.of(
+                "CustomSheet!A1:D5", "replacement"
+        ), Mode.CELL).get();
+
+        ByteArrayInputStream bis = new ByteArrayInputStream(excelBytes);
+        Workbook workbook = WorkbookFactory.create(bis);
+        var otherSheet = workbook.getSheet("CustomSheet");
+
+        for (int rowNum = 0; rowNum < 4; rowNum++) {
+            for (int cellNum = 0; cellNum < 4; cellNum++) {
+                assertEquals("replacement", otherSheet.getRow(rowNum).getCell(cellNum).getStringCellValue());
+            }
+        }
+
+    }
+
+    @Test
+    void testReferenceInvalidSheet() {
+        var logging = new TestLogging();
+        var parser = new ExcelParser(TestUtil.getXlsFile(), logging);
+        var excelBytes = parser.readAndReplace(Map.of(
+                "SheetDoesNotExist!B21", "otherSheetB21"
+        ), Mode.CELL);
+
+        assertEquals(Optional.empty(), excelBytes);
+    }
+
+
+    private List<String> getAllCellValues(byte[] excelBytes) throws IOException {
+        List<String> cellValues = new ArrayList<>();
+
+        ByteArrayInputStream bis = new ByteArrayInputStream(excelBytes);
+        Workbook workbook = WorkbookFactory.create(bis);
+
+        for (int i = 0; i < workbook.getNumberOfSheets(); i++) {
+            Sheet sheet = workbook.getSheetAt(i);
+            for (Row row : sheet) {
+                for (Cell cell : row) {
+                    if (cell.getCellType().equals(CellType.STRING)) {
+                        cellValues.add(cell.getStringCellValue());
+                    }
+                }
+            }
+        }
+
+        bis.close();
+        return cellValues;
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/ch/redguard/burp/sheet_intruder/mock/TestByteUtils.java b/src/test/java/ch/redguard/burp/sheet_intruder/mock/TestByteUtils.java
new file mode 100644
index 0000000..ede73bb
--- /dev/null
+++ b/src/test/java/ch/redguard/burp/sheet_intruder/mock/TestByteUtils.java
@@ -0,0 +1,102 @@
+package ch.redguard.burp.sheet_intruder.mock;
+
+import burp.api.montoya.utilities.ByteUtils;
+
+import java.util.Arrays;
+import java.util.regex.Pattern;
+
+public class TestByteUtils implements ByteUtils {
+
+    @Override
+    public int indexOf(byte[] data, byte[] searchTerm) {
+        return indexOf(data, searchTerm, true);
+    }
+
+    @Override
+    public int indexOf(byte[] data, byte[] searchTerm, boolean caseSensitive) {
+        return indexOf(data, searchTerm, caseSensitive, 0, data.length);
+    }
+
+    @Override
+    public int indexOf(byte[] data, byte[] searchTerm, boolean caseSensitive, int from, int to) {
+        if (!caseSensitive) {
+            data = new String(data).toLowerCase().getBytes();
+            searchTerm = new String(searchTerm).toLowerCase().getBytes();
+        }
+
+        for (int i = from; i < to - searchTerm.length + 1; i++) {
+            if (Arrays.equals(Arrays.copyOfRange(data, i, i + searchTerm.length), searchTerm)) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    @Override
+    public int indexOf(byte[] data, Pattern pattern) {
+        return indexOf(data, pattern, 0, data.length);
+    }
+
+    @Override
+    public int indexOf(byte[] data, Pattern pattern, int from, int to) {
+        // Convert byte array to String for pattern matching
+        String dataString = convertToString(data);
+
+        String subDataString = dataString.substring(from, to);
+        java.util.regex.Matcher matcher = pattern.matcher(subDataString);
+        if (matcher.find()) {
+            return from + matcher.start();
+        }
+        return -1;
+    }
+
+    @Override
+    public int countMatches(byte[] data, byte[] searchTerm) {
+        return countMatches(data, searchTerm, true);
+    }
+
+    @Override
+    public int countMatches(byte[] data, byte[] searchTerm, boolean caseSensitive) {
+        return countMatches(data, searchTerm, caseSensitive, 0, data.length);
+    }
+
+    @Override
+    public int countMatches(byte[] data, byte[] searchTerm, boolean caseSensitive, int from, int to) {
+        int count = 0;
+        int idx = from;
+        while ((idx = indexOf(data, searchTerm, caseSensitive, idx, to)) != -1) {
+            count++;
+            idx += searchTerm.length;
+        }
+        return count;
+    }
+
+    public int countMatches(byte[] data, Pattern pattern) {
+        return countMatches(data, pattern, 0, data.length);
+    }
+
+    @Override
+    public int countMatches(byte[] data, Pattern pattern, int from, int to) {
+        int count = 0;
+        int index = from;
+        while (index >= 0 && index < to) {
+            index = indexOf(data, pattern, index, to);
+            if (index >= 0) {
+                count++;
+                index++;
+            }
+        }
+        return count;
+    }
+
+
+    @Override
+    public String convertToString(byte[] bytes) {
+        return new String(bytes);
+    }
+
+    @Override
+    public byte[] convertFromString(String string) {
+        return string.getBytes();
+    }
+}
diff --git a/src/test/java/ch/redguard/burp/sheet_intruder/parser/JsonParserTest.java b/src/test/java/ch/redguard/burp/sheet_intruder/parser/JsonParserTest.java
new file mode 100644
index 0000000..f146659
--- /dev/null
+++ b/src/test/java/ch/redguard/burp/sheet_intruder/parser/JsonParserTest.java
@@ -0,0 +1,81 @@
+package ch.redguard.burp.sheet_intruder.parser;
+
+import ch.redguard.burp.sheet_intruder.TestLogging;
+import ch.redguard.burp.sheet_intruder.mock.TestByteUtils;
+import org.junit.jupiter.api.Test;
+
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class JsonParserTest {
+
+    @Test
+    void parseJson() {
+        TestLogging logging = new TestLogging();
+        var tagParser = new TagByteParser("""
+                test<$SheetIntruder>
+                {
+                    "valueToReplace": "replacement",
+                    "valueToReplace2": "replacement2"
+                }
+                </$SheetIntruder>
+                """.getBytes(),
+                new TestByteUtils(),
+                logging
+        );
+        var hashMap = new JsonParser(tagParser.getTagContent().getContent(), logging).parseJson();
+
+        var expectedHashMap = Map.of(
+                "valueToReplace", "replacement",
+                "valueToReplace2", "replacement2"
+        );
+
+        assertEquals(expectedHashMap, hashMap);
+    }
+
+    @Test
+    void parseJsonCellMode() {
+        TestLogging logging = new TestLogging();
+        var tagParser = new TagByteParser("""
+                test<$SheetIntruderCell>
+                {
+                    "A1": "replacement",
+                    "B1": "replacement2"
+                }
+                </$SheetIntruderCell>
+                """.getBytes(),
+                new TestByteUtils(),
+                logging
+        );
+        var hashMap = new JsonParser(tagParser.getTagContent().getContent(), logging).parseJson();
+
+        var expectedHashMap = Map.of(
+                "A1", "replacement",
+                "B1", "replacement2"
+        );
+
+        assertEquals(expectedHashMap, hashMap);
+    }
+
+    @Test
+    void parseInvalidJson() {
+        TestLogging logging = new TestLogging();
+        var tagParser = new TagByteParser("""
+                <$SheetIntruderCell>
+                {
+                    "A1": "replacement":
+                    "B1": "replacement2"
+                                
+                </$SheetIntruderCell>
+                """.getBytes(),
+                new TestByteUtils(),
+                logging
+        );
+        var hashMap = new JsonParser(tagParser.getTagContent().getContent(), logging).parseJson();
+
+        var expectedHashMap = Map.of();
+
+        assertEquals(expectedHashMap, hashMap);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/ch/redguard/burp/sheet_intruder/parser/ParsedTagByteParserTest.java b/src/test/java/ch/redguard/burp/sheet_intruder/parser/ParsedTagByteParserTest.java
new file mode 100644
index 0000000..593637e
--- /dev/null
+++ b/src/test/java/ch/redguard/burp/sheet_intruder/parser/ParsedTagByteParserTest.java
@@ -0,0 +1,50 @@
+package ch.redguard.burp.sheet_intruder.parser;
+
+import ch.redguard.burp.sheet_intruder.TestLogging;
+import ch.redguard.burp.sheet_intruder.mock.TestByteUtils;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ParsedTagByteParserTest {
+
+    @Test
+    void getTagContent() {
+        var tagParser = new TagByteParser("test<$SheetIntruder>content</$SheetIntruder>".getBytes(),
+                new TestByteUtils(), new TestLogging());
+        assertEquals("content", new String(tagParser.getTagContent().getContent()));
+    }
+
+    @Test
+    void getTagContentCellMode() {
+        var tagParser = new TagByteParser("test<$SheetIntruderCell>content</$SheetIntruderCell>".getBytes(),
+                new TestByteUtils(), new TestLogging());
+        assertEquals("content", new String(tagParser.getTagContent().getContent()));
+        assertEquals(Mode.CELL, tagParser.getTagContent().getMode());
+    }
+
+    @Test
+    void testEmptyTag() {
+        var tagParser = new TagByteParser("test<$SheetIntruderCell></$SheetIntruderCell>".getBytes(),
+                new TestByteUtils(), new TestLogging());
+        assertEquals("", new String(tagParser.getTagContent().getContent()));
+        assertEquals(Mode.CELL, tagParser.getTagContent().getMode());
+    }
+
+    @Test
+    void testInvalidTag() {
+        var tagParser = new TagByteParser("test<$SheetIntruderCelltestse></$SheetIntruderCell>".getBytes(),
+                new TestByteUtils(), new TestLogging());
+        assertTrue(tagParser.getTagContent().isEmptyOrInvalid());
+        assertEquals(Mode.DEFAULT, tagParser.getTagContent().getMode());
+    }
+
+    @Test
+    void testMismatchedTag() {
+        var tagParser = new TagByteParser("test<$SheetIntruder></$SheetIntruderCell>".getBytes(), new TestByteUtils()
+                , new TestLogging());
+        assertTrue(tagParser.getTagContent().isEmptyOrInvalid());
+        assertEquals(Mode.DEFAULT, tagParser.getTagContent().getMode());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/ch/redguard/burp/sheet_intruder/parser/ReplacerTest.java b/src/test/java/ch/redguard/burp/sheet_intruder/parser/ReplacerTest.java
new file mode 100644
index 0000000..27dcf7f
--- /dev/null
+++ b/src/test/java/ch/redguard/burp/sheet_intruder/parser/ReplacerTest.java
@@ -0,0 +1,96 @@
+package ch.redguard.burp.sheet_intruder.parser;
+
+import burp.api.montoya.logging.Logging;
+import ch.redguard.burp.sheet_intruder.TestLogging;
+import ch.redguard.burp.sheet_intruder.TestUtil;
+import ch.redguard.burp.sheet_intruder.excel.ExcelParser;
+import ch.redguard.burp.sheet_intruder.mock.TestByteUtils;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ReplacerTest {
+
+    @Test
+    public void testReplaceAllStrings() {
+        String start = "some request data, headers";
+        String tagStr = """
+                <$SheetIntruder>
+                {
+                    "valueToReplace": "replacement",
+                    "valueToReplace2": "replacement2"
+                }
+                </$SheetIntruder>
+                """;
+        String end = "Some end data";
+
+        byte[] body = (start + tagStr + end).getBytes();
+
+        var replacements = Map.of(
+                "valueToReplace", "replacement",
+                "valueToReplace2", "replacement2"
+        );
+        File file = TestUtil.getXlsxFile();
+        Logging logging = new TestLogging();
+        TagByteParser tagByteParser = new TagByteParser(body, new TestByteUtils(), new TestLogging());
+
+        var tag = tagByteParser.getTagContent();
+        Replacer replacer = new Replacer(body, replacements, tag, file, logging);
+
+        var excelBytes = new ExcelParser(file, logging).readAndReplace(replacements, tag.getMode()).get();
+
+        byte[] fullReplacedBody = replacer.getReplacedBody().get();
+
+        assertTrue(new String(fullReplacedBody).startsWith(start));
+        assertTrue(new String(fullReplacedBody).endsWith(end));
+
+        assertEquals(
+                start.getBytes().length + excelBytes.length + end.getBytes().length,
+                fullReplacedBody.length - 1
+        );
+    }
+
+    @Test
+    public void testReplaceCellMode() {
+        String start = "some request data, headers";
+        String tagStr = """
+                <$SheetIntruderCell>
+                {
+                    "A1": "replacement",
+                    "B1": "replacement2"
+                }
+                </$SheetIntruderCell>
+                """;
+        String end = "Some end data";
+
+        byte[] body = (start + tagStr + end).getBytes();
+
+        var replacements = Map.of(
+                "A1", "replacement",
+                "B1", "replacement2"
+        );
+        File file = TestUtil.getXlsxFile();
+        Logging logging = new TestLogging();
+        TagByteParser tagByteParser = new TagByteParser(body, new TestByteUtils(), new TestLogging());
+
+        var tag = tagByteParser.getTagContent();
+
+        Replacer replacer = new Replacer(body, replacements, tag, file, logging);
+
+        var excelBytes = new ExcelParser(file, logging).readAndReplace(replacements, tag.getMode()).get();
+
+        byte[] fullReplacedBody = replacer.getReplacedBody().get();
+
+        assertTrue(new String(fullReplacedBody).startsWith(start));
+        assertTrue(new String(fullReplacedBody).endsWith(end));
+
+        assertEquals(
+                start.getBytes().length + excelBytes.length + end.getBytes().length,
+                fullReplacedBody.length - 1
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/test/resources/Book1.xls b/src/test/resources/Book1.xls
new file mode 100644
index 0000000..941d13b
Binary files /dev/null and b/src/test/resources/Book1.xls differ
diff --git a/src/test/resources/Book1.xlsx b/src/test/resources/Book1.xlsx
new file mode 100644
index 0000000..6b384d5
Binary files /dev/null and b/src/test/resources/Book1.xlsx differ
diff --git a/testServer/Dockerfile b/testServer/Dockerfile
new file mode 100644
index 0000000..089139d
--- /dev/null
+++ b/testServer/Dockerfile
@@ -0,0 +1,23 @@
+# Use an official Python runtime as a parent image
+FROM python:3.11-alpine
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy only the necessary files into the container
+COPY server.py requirements.txt /app/
+
+# Create a non-root user to run the application
+RUN addgroup -S appuser && adduser -S appuser -G appuser && \
+    chown -R appuser:appuser /app
+
+# Switch to the non-root user
+USER appuser
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 5000
+
+# Run the command to start the Flask application
+CMD ["python3", "server.py"]
diff --git a/testServer/requirements.txt b/testServer/requirements.txt
new file mode 100644
index 0000000..6a5d2d8
--- /dev/null
+++ b/testServer/requirements.txt
@@ -0,0 +1,2 @@
+flask==2.3.2
+Werkzeug==2.3.7
\ No newline at end of file
diff --git a/testServer/server.py b/testServer/server.py
new file mode 100644
index 0000000..91dc791
--- /dev/null
+++ b/testServer/server.py
@@ -0,0 +1,46 @@
+import os
+from flask import Flask, flash, request, redirect, url_for, make_response
+from werkzeug.utils import secure_filename
+import datetime
+
+ALLOWED_EXTENSIONS = {'xls', 'xlsx'}
+
+app = Flask(__name__)
+app.config['UPLOAD_FOLDER'] = "/output"
+
+
+def allowed_file(filename):
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
+
+@app.route('/', methods=['GET', 'POST'])
+def upload_file():
+    if request.method == 'POST':
+        # check if the post request has the file part
+        if 'file' not in request.files:
+            flash('No file part')
+            return redirect(request.url)
+        file = request.files['file']
+        # If the user does not select a file, the browser submits an
+        # empty file without a filename.
+        if file.filename == '':
+            flash('No selected file')
+            return redirect(request.url)
+        if file and allowed_file(file.filename):
+            filename = secure_filename(datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S-") + file.filename)
+            file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
+            return make_response(f"Received file of length {file.seek(0, os.SEEK_END)}")
+    return '''
+    <!doctype html>
+    <title>Upload new File</title>
+    <h1>Upload new File</h1>
+    <form method=post enctype=multipart/form-data>
+      <input type=file name=file>
+      <input type=submit value=Upload>
+    </form>
+    '''
+
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", debug=True)
\ No newline at end of file