Image Tampering Detection Models and

Digital Forensics Techniques

Initial Research Findings

Image tampering detection based on RDS-YOLOv5

feature enhancement transformation

Abstract

Malicious image tampering has gradually become another way to threaten social
stability and personal safety. Timely detection and precise positioning can help reduce
the occurrence of risks and improve the overall safety of society. Due to the limitations
of highly targeted dataset training and low-level feature extraction efficiency, the
generalization and actual performance of the recent tampered detection technology
have not yet reached expectations. In this study, we propose a tampered image
detection method based on RDS-YOLOv5 feature enhancement transformation. Firstly,
a multi-channel feature enhancement fusion algorithm is proposed to enhance the
tampering traces in tampered images. Then, an improved deep learning model named
RDS-YOLOv5 is proposed for the recognition of tampered images, and a nonlinear loss
metric of aspect ratio was introduced into the original SIOU loss function to better
optimize the training process of the model. Finally, RDS-YOLOv5 is trained by
combining the features of the original image and the enhancement image to improve
the robustness of the detection model. A total of 6187 images containing three forms
of tampering: splice, remove, and copy-move were used to comprehensively evaluate
the proposed algorithm. In ablation test, compared with the original YOLOv5 model,
RDS-YOLOv5 achieved a performance improvement of 6.46%, 5.13%, and 3.15% on F1-
Score, mAP50 and mAP95, respectively. In comparative experiments, using SRIOU as
the loss function significantly improved the model’s ability to search for the real
tampered regions by 2.54%. And the RDS-YOLOv5 model trained by the fusion dataset
further improved the comprehensive detection performance by about 1%.

Introduction

As one of the important ways for human beings to perceive and understand the world,
images have gradually been integrated into all aspects of our daily life. With the
vigorous development of science and technology as well as people’s growing
material and spiritual needs, a variety of image “beauty” software has also been
favored by more and more people. People can easily and conveniently make various
custom edits and modifications to the image to achieve their purpose and needs, but
it also creates a lot of problems and troubles. The falsification of identity photo
information, the tampering of receipt type images, and the malicious smearing and
exaggerated rendering of real images have gradually become new means to endanger
social security. Therefore, rapid and effective detection and localization of tampering
regions in images is of crucial significance for the security and stable development of
society.

Currently, there are three main types of image tampering forms: copy-move, remove,
and splice. Generally speaking, these three operations will leave more or less traces of
digital processing on the original image, which can be used as an effective basis for
discrimination. However, for some exquisitely retouched images, due to the addition
of image filtering, smoothing, light adjustment and other subsequent processing, it is
difficult for ordinary people to distinguish such images, and even for professionals, it is
often difficult to see through at a glance. This has prompted relevant scholars to try to
use artificial intelligence technology to capture the traces of image tampering.
Muhammad Hussain et al. proposed a multi-resolution Weber law descriptor based on
the tampering detection method of copy-move images, which tries to extract features
from the chromaticity components of the image to capture the relative information of
different neighborhoods in the image, and then uses the support vector machine to
classify it to obtain the final discriminant result1. Jiachen Yang et al. proposed a multi-
scale self-texture attention generation network, which simulated the forgery process
based on image generation from the perspective of image generation, and traced
potential forgery traces and texture features. Finally, based on the loss function of the
classification probability constraint, the generation and monitoring process of forgery
traces can be directly corrected2. Shilpa Dua et al. proposed an image forgery
detection technology based on image artifact coding analysis, which divides the JPEG
compressed image into several non-overlapping blocks, and then performs an
independent discrete cosine transformation on each block, generates the
corresponding feature vectors through the evaluation and counting of the
transformation coefficients, and then uses the support vector machine to realize the
image discrimination3. Rani Susan Oommen et al. proposed a hybrid method based
on Local Shape Dimension (LFD) and Singular Value Decomposition (SVD) to effectively
detect and locate duplicate forgery regions in images. Firstly, the image is divided into
fixed-size fast, the shape dimension of the local part is estimated, and then the image
blocks are arranged into a B + tree based on the LFD value, and the image blocks in
each fragment are compared with the singular value, so as to narrow the comparison
range, effectively reduce the complexity of calculation and quickly screen the
duplicate parts in the image4. Other tampering detection methods using wavelet
transform, DCT features, and variant neural networks have also achieved certain
results in their respective screening tasks5,6,7,8,9,10,11,12. However, most of the
proposed methods are for specific types of images and data, and the relevant deep
learning models are also inefficient at extracting features from the input original
tampering images.

In this study, we first designed an image preprocessing algorithm based on multi-

channel feature enhancement fusion for tampering images, which was used to
enhance the features of the tampered regions in the tampered image, and amplify the
tampering details in the tampered images from multiple perspectives such as light,
texture, and transformation domain, so as to improve the feature extraction efficiency
of the subsequent model. Then, we proposed an improved YOLOv5 model, which
introduces the residual structure, the multi-branch dynamic kernel selection channel
attention mechanism and the SPD convolution module on the basis of the original
network structure, and optimizes the loss function of the model to further improve the
fitting ability of the model. Finally, we combined the preprocessed enhanced image
with the original tampered image for weight fusion as input to the improved model to
achieve higher detection performance.

How to Detect Image Tampering Using Image

Forensics and AI

Image tampering, also known as image forgery, refers to the manipulation or

alteration of images with the intent to deceive, mislead, or misrepresent information
contained within the image.
Techniques such as copy move, splicing, inpainting, or deepfakes, can add, remove, or
modify elements, creating misleading visuals.

Copy move or photomontage

Copy move or photomontage is a type of image manipulation in which a region from

one part of an image is copied and pasted onto another part of the same image to hide
information or create a false appearance. It involves duplicating and placing an object
in a different location to conceal or add elements to an image.

Splicing

Splicing is a technique where different parts of multiple images are combined to form
a single, deceptive image. This type of tampering often involves merging multiple
photographs or altering the content of individual photographs to create a misleading
representation of an event or object.

Inpainted

Inpainted images involve the removal or alteration of objects or areas within an image
by filling in the gaps with newly created, artificial content. The goal of this technique is
to ensure that the inpainted sections blend seamlessly with the rest of the image,
making it challenging to detect any modifications.

Deepfakes

Deepfakes refer to manipulated images or videos in which the face or appearance of a

person is replaced with someone else’s using deep learning techniques. These
sophisticated forgeries can make it appear that someone said or did something they
didn’t. Deepfakes have raised concerns about the potential for misinformation and
fake content.

Mobile-Optimized Image Tampering Detection Models

From the initial search, several promising avenues for mobile-optimized image
tampering detection have emerged. These include approaches leveraging lightweight
deep learning models and techniques specifically designed for mobile environments.
Key Models and Approaches:

RDS-YOLOv5: The Nature article [1] discusses an improved YOLOv5 model (RDS-
YOLOv5) for tampered image detection. This model incorporates a multi-channel
feature enhancement fusion algorithm and optimizes the loss function. While not
explicitly stated as mobile-optimized, YOLOv5 models are generally known for
their efficiency and can be adapted for mobile deployment.

MobileNet: The IEEE Xplore document [2] mentions "Improved Accuracy in

Image Tampering Detection using MobileNet." MobileNet architectures are
specifically designed for mobile and embedded vision applications, making them
strong candidates for this project due to their efficiency and reduced
computational requirements.

Lightweight Deep Learning Models (General): Several search results [3, 4, 5, 6]

highlight the use of lightweight deep learning models for image forensics,
including SqueezeNet, MobileNetV2, and ShuffleNet. These models prioritize
efficiency and reduced model size, which are crucial for mobile deployment.

Traditional Image Forensics Techniques: While the focus is on deep learning,

it's important to acknowledge traditional techniques like Error Level Analysis
(ELA), metadata analysis, clone detection, and noise analysis, as mentioned in
various articles [7, 8]. These techniques can be computationally less intensive
and might offer complementary insights or be suitable for simpler mobile
implementations.

Considerations for Mobile Deployment:

When selecting an optimal model architecture for Android deployment, the following
factors are critical:

Model Size: Smaller models consume less storage space on the device and are
faster to download and load.

Inference Speed: The model must be able to process images quickly on mobile
hardware to provide a responsive user experience.

Computational Resources: Mobile devices have limited CPU, GPU, and memory.
The chosen model should have low computational complexity.
 Accuracy: Despite optimization, the model must maintain a high level of
accuracy in detecting various types of image tampering.

Power Consumption: Efficient models lead to less battery drain.

Framework Compatibility: Compatibility with mobile deep learning frameworks

like TensorFlow Lite or PyTorch Mobile is essential for deployment.

Initial Assessment:

Based on the initial research, MobileNet architectures appear to be the most

promising starting point due to their explicit design for mobile environments and their
proven performance in various computer vision tasks. Further investigation into
specific MobileNet variants and their application in image tampering detection is
warranted. Additionally, exploring how the feature enhancement techniques from
RDS-YOLOv5 could be integrated with lightweight architectures might yield a more
robust and efficient solution.

References:

[1] https://www.nature.com/articles/s41598-024-76388-9 [2]

https://ieeexplore.ieee.org/document/10125988/ [3] https://www.mdpi.com/2073-
8994/15/12/2096 [4] https://ieeexplore.ieee.org/document/9378690/ [5]
https://www.ijcnis.org/index.php/ijcnis/article/view/7918/2141 [6]
https://arxiv.org/html/2411.11826v1 [7] https://medium.com/@18218004/digital-
forensics-blog-03-image-forensics-first-time-detecting-image-tampering-
b531707563fe [8] https://29a.ch/photo-forensics/

Analysis of MobileNetV2 and MobileNetV3 for Image

Tampering Detection

MobileNetV2 and MobileNetV3 are strong candidates for mobile-optimized image

tampering detection due to their efficient architectures. Both are designed to deliver
high performance on resource-constrained devices, making them ideal for Android
applications.
MobileNetV2:

Architecture: MobileNetV2 introduces the inverted residual block with linear

bottlenecks. This design significantly reduces the number of parameters and
computational operations while maintaining accuracy. The inverted residuals
allow the network to learn richer representations with fewer parameters, and the
linear bottlenecks prevent information loss in low-dimensional spaces.

Performance in Image Tampering: Several studies indicate MobileNetV2's

effectiveness. For instance, [9] mentions a lightweight image splicing tampering
localization method based on MobileNetV2. Another paper [10] highlights that
MobileNetV2 can achieve high detection accuracy (around 95%) with fewer
training parameters, leading to faster training times. This is crucial for iterative
development and deployment.

Advantages for Mobile: Its small model size and efficient inference make it
suitable for on-device processing, reducing latency and reliance on cloud
resources.

MobileNetV3:

Architecture: MobileNetV3 builds upon MobileNetV2 by introducing a new, more

efficient building block called the "squeeze-and-excitation" module and
optimizing the network architecture through neural architecture search (NAS). It
also incorporates a new activation function, h-swish, which is a more
computationally efficient alternative to ReLU6.

Performance in Image Tampering: MobileNetV3 is also being explored for

image tampering detection, particularly for deepfake detection [11, 12]. Its
enhanced efficiency and improved accuracy over MobileNetV2 make it a
compelling option, especially for more complex tampering types like deepfakes.

Advantages for Mobile: Offers further improvements in latency and accuracy

compared to MobileNetV2, making it even more suitable for real-time mobile
applications.

Datasets for Training and Validation:

To effectively train and validate the chosen model, access to comprehensive image
tampering datasets is essential. The search results provided several valuable
resources:
 Original and Tampered Image Dataset (Kaggle): [13] This dataset is specifically
designed for training and validating machine learning models for classifying
tampered images.

CASIA 2.0 Image Tampering Detection Dataset (Kaggle): [14] A widely used
dataset in image forensics research, containing various types of tampering.

Image Forgery Datasets List (GitHub): [15] A curated list of various image
forgery datasets, offering a broader range of tampering types and image sources.

CG-1050 Dataset: [16] This dataset contains 100 original images, 1050 tampered
images, and their corresponding masks, useful for both detection and
localization tasks.

Optimal Model Selection:

Considering the need for a robust and efficient solution for mobile deployment,
MobileNetV3 appears to be the optimal choice. While MobileNetV2 is highly capable,
MobileNetV3 offers further architectural improvements that lead to better
performance and efficiency. Its suitability for deepfake detection also suggests its
potential for handling more sophisticated tampering techniques. The availability of
relevant datasets will be crucial for training and fine-tuning the chosen MobileNetV3
model.

References:

[9] https://ietresearch.onlinelibrary.wiley.com/doi/full/10.1049/ipr2.12763 [10]

https://ieeexplore.ieee.org/document/10226188/ [11]
https://dl.acm.org/doi/abs/10.1007/978-3-031-84543-7_11 [12]
https://link.springer.com/content/pdf/10.1007/978-3-031-84543-7_11 [13]
https://www.kaggle.com/datasets/saurabhshahane/cg1050 [14]
https://www.kaggle.com/datasets/divg07/casia-20-image-tampering-detection-
dataset [15] https://github.com/greatzh/Image-Forgery-Datasets-List [16]
https://pmc.ncbi.nlm.nih.gov/articles/PMC6909131/
MobileNetV3 Model Selection, Fine-tuning, and
TensorFlow Lite Conversion

To develop an image tampering detection model optimized for Android mobile

applications, a pre-trained MobileNetV3 model will be utilized. This approach
leverages the power of transfer learning, allowing us to adapt a model already trained
on a vast dataset (like ImageNet) to our specific task of image tampering detection
with a relatively smaller, task-specific dataset.

1. Identifying a Suitable Pre-trained MobileNetV3 Model

Pre-trained MobileNetV3 models are readily available in popular deep learning

frameworks such as TensorFlow/Keras and PyTorch. For Android deployment with
TensorFlow Lite, a TensorFlow-compatible pre-trained model is preferred. Keras, being
a high-level API for TensorFlow, offers convenient access to these models.

MobileNetV3Large and MobileNetV3Small are the two main variants.

MobileNetV3Small is more suitable for highly resource-constrained
environments, while MobileNetV3Large offers better accuracy with a slight
increase in computational cost. The choice between them will depend on the
specific performance requirements and the target Android device capabilities.

These models are typically pre-trained on the ImageNet dataset for image
classification. While ImageNet does not contain tampered images, the features
learned by the model (e.g., edge detection, texture recognition) are highly
transferable to other image-related tasks, including anomaly detection like
image tampering.

2. Fine-tuning for Image Tampering Detection

Fine-tuning involves adapting the pre-trained MobileNetV3 model to the specific task
of image tampering detection using a relevant dataset. The process generally includes
the following steps:

Dataset Preparation: Utilize image tampering datasets such as CASIA 2.0, CG-
1050, or custom datasets containing both authentic and tampered images. The
dataset should be split into training, validation, and test sets.
 Model Modification: The top layers of the pre-trained MobileNetV3 model (the
classification head) will be removed. New layers, typically a global average
pooling layer, a dense layer, and a final classification layer (with a sigmoid
activation for binary classification or softmax for multi-class classification if
different tampering types are to be identified), will be added.

Freezing Base Layers: Initially, the weights of the pre-trained MobileNetV3 base
layers will be frozen. This prevents large gradient updates from corrupting the
learned features during the initial training phase with the new top layers.

Training New Layers: The model will be trained for a few epochs, allowing the
newly added layers to learn to classify tampered images based on the features
extracted by the frozen base model.

Unfreezing and Fine-tuning: After the initial training, a portion or all of the base
layers can be unfrozen. The entire model is then fine-tuned with a very low
learning rate. This allows the model to slightly adjust the pre-trained weights to
better suit the image tampering detection task while preserving the general
features learned during pre-training.

Loss Function and Optimizer: Binary cross-entropy is a suitable loss function for
binary classification (tampered/authentic). Optimizers like Adam or RMSprop are
commonly used.

3. Conversion to TensorFlow Lite (TFLite)

Once the MobileNetV3 model is fine-tuned and evaluated, it needs to be converted to

the TensorFlow Lite format for efficient deployment on Android devices. TensorFlow
Lite models are optimized for on-device inference, offering reduced model size and
faster execution.

TFLiteConverter: TensorFlow provides the TFLiteConverter API to convert

TensorFlow models (Keras models, SavedModels, or Concrete Functions) into the
TFLite format. The conversion process can include various optimizations.

Quantization: This is a crucial step for mobile deployment. Quantization reduces

the precision of the model's weights and activations (e.g., from floating-point to
8-bit integers), significantly decreasing the model size and improving inference
speed with minimal loss in accuracy. Post-training quantization is a common
technique where the model is quantized after training.
 Dynamic Range Quantization: Quantizes only the weights to 8-bit integers
and dynamically quantizes activations during inference. This is the simplest
form of quantization.

Full Integer Quantization: Quantizes both weights and activations to 8-bit

integers. This requires a representative dataset for calibration during
conversion but offers the highest performance benefits on compatible
hardware.

Output: The conversion process will generate a .tflite file, which is the
optimized model ready for integration into the Android application.
Example Workflow (Conceptual Python Code):

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# 1. Load pre-trained MobileNetV3 (e.g., MobileNetV3Large)

base_model = keras.applications.MobileNetV3Large(input_shape=(224, 224, 3),
include_top=False,
weights='imagenet')

# 2. Fine-tuning setup
base_model.trainable = False # Freeze the base model

inputs = keras.Input(shape=(224, 224, 3))

x = base_model(inputs, training=False)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(128, activation='relu')(x)
outputs = layers.Dense(1, activation='sigmoid')(x) # Binary classification

model = keras.Model(inputs, outputs)

model.compile(optimizer=keras.optimizers.Adam(),
loss=keras.losses.BinaryCrossentropy(),
metrics=[keras.metrics.BinaryAccuracy()])

# Assuming you have your dataset loaded as tf.data.Dataset objects

# train_ds, val_ds

# Train the new layers

# model.fit(train_ds, epochs=10, validation_data=val_ds)

# Unfreeze and fine-tune (optional, for better accuracy)

# base_model.trainable = True
# model.compile(optimizer=keras.optimizers.Adam(1e-5), # Very low learning rate
# loss=keras.losses.BinaryCrossentropy(),
# metrics=[keras.metrics.BinaryAccuracy()])
# model.fit(train_ds, epochs=10, validation_data=val_ds)

# 3. Convert to TensorFlow Lite

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
# For full integer quantization, you would need a representative dataset
# converter.representative_dataset = representative_dataset_generator
# converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]

tflite_model = converter.convert()

# Save the TFLite model

# with open('image_tampering_detector.tflite', 'wb') as f:
# f.write(tflite_model)

This .tflite model will then be integrated into the Android application for on-device
image tampering detection.
Android Application Architecture and Development
Process

Developing an Android application to integrate the MobileNetV3 TFLite model for

image tampering detection involves several key architectural components and a
structured development process. The application will provide a user-friendly interface
for selecting images, performing on-device analysis, and displaying the detection
results.

1. Application Architecture Overview

The Android application will follow a typical Model-View-ViewModel (MVVM) or Model-

View-Presenter (MVP) architecture to ensure a clean separation of concerns, testability,
and maintainability. Key components will include:

User Interface (UI): Activities and Fragments for user interaction, image display,
and result presentation.

Image Selection/Capture Module: Handles selecting images from the device's

gallery or capturing new images using the camera.

TFLite Inference Module: Encapsulates the logic for loading the TFLite model
and performing inference on input images.

Result Display Module: Responsible for visualizing the tampering detection

results to the user.

Utility/Helper Classes: For image preprocessing, post-processing, and other

common tasks.

2. Key Development Steps

2.1 Project Setup and Dependencies

Android Studio: The primary IDE for Android application development.

Gradle: The build automation system for managing dependencies.

TensorFlow Lite Library: Include the necessary TensorFlow Lite AAR (Android
Archive) library in the build.gradle file to enable TFLite model loading and
inference. gradle dependencies { implementation
 'org.tensorflow:tensorflow-lite-task-vision:0.4.0' // Or the latest
version implementation 'org.tensorflow:tensorflow-lite-gpu:2.x.x' //
For GPU delegation, if supported // Other necessary AndroidX
libraries }

2.2 User Interface (UI) Design

Main Activity: A central activity to initiate image selection or capture.

Image Display: An ImageView to display the selected image.

Action Buttons: Buttons for "Select Image," "Analyze Image," etc.

Result Display: A TextView or custom View to show the detection probability

or a visual indicator of tampering.

2.3 Image Input and Preprocessing

Image Selection: Implement an Intent to allow users to pick images from their
gallery ( ACTION_PICK or ACTION_GET_CONTENT ).

Camera Capture: Implement an Intent to capture new images using the

device's camera ( ACTION_IMAGE_CAPTURE ).

Image Loading: Load the selected image into a Bitmap object.

Preprocessing: Before feeding the image to the TFLite model, it needs to be

preprocessed to match the model's input requirements (e.g., resizing to 224x224
pixels, normalizing pixel values to a specific range like [0, 1] or [-1, 1], and
converting to a ByteBuffer ).

2.4 TFLite Model Integration and Inference

Model Placement: Place the image_tampering_detector.tflite model file in

the assets folder of the Android project.

Model Loading: Load the TFLite model using Interpreter or Task API
(recommended for common vision tasks). ```java // Using Task API (example for
image classification) ImageClassifier.ImageClassifierOptions options =
ImageClassifier.ImageClassifierOptions.builder()
.setBaseOptions(BaseOptions.builder().useGpu().build()) .setMaxResults(1) // Or
more, depending on output .build(); ImageClassifier imageClassifier =
 ImageClassifier.createFromFileAndOptions(context,
"image_tampering_detector.tflite", options);

// Or using Interpreter directly for more control // ByteBuffer modelBuffer =

loadModelFile(activity, "image_tampering_detector.tflite"); // Interpreter.Options
options = new Interpreter.Options(); // Interpreter tflite = new
Interpreter(modelBuffer, options); `` * **Inference:** Pass the
preprocessed ByteBuffer representing the image to the TFLite
interpreter for inference. The output will be a ByteBuffer` containing
the model's predictions (e.g., a probability score for tampering).

2.5 Result Post-processing and Display

Post-processing: Convert the model's raw output (e.g., a float value between 0
and 1) into a human-readable format (e.g., a percentage or a clear "Tampered" or
"Authentic" label).

UI Update: Update the UI to display the detection result. This could involve:
A simple text message: "Image is likely tampered (75% confidence)."

Color-coded indicators: Red for tampered, green for authentic.

Overlaying a heatmap or bounding box if the model provides localization

information.

2.6 Permissions

Declare necessary permissions in AndroidManifest.xml for accessing storage

( READ_EXTERNAL_STORAGE , WRITE_EXTERNAL_STORAGE for older Android versions,
or using Storage Access Framework) and camera ( CAMERA ).

2.7 Error Handling and User Feedback

Implement robust error handling for cases like invalid image selection, model
loading failures, or inference errors.

Provide clear feedback to the user throughout the process (e.g., "Analyzing
image...", "Analysis complete.", "Error: Could not process image.").
3. Development Best Practices

Asynchronous Operations: Perform all TFLite model loading and inference

operations on a background thread (e.g., using Kotlin Coroutines, RxJava, or
AsyncTask for older Java projects) to prevent blocking the UI thread and ensure
a smooth user experience.

Memory Management: Be mindful of memory usage, especially when dealing

with large images. Efficiently load and release Bitmap objects.

Performance Optimization: Profile the application to identify and address

performance bottlenecks. Consider using GPU delegation for TFLite inference if
the target devices support it.

User Experience (UX): Design an intuitive and responsive UI. Provide progress
indicators during analysis.

Security: Ensure proper handling of user data and permissions.

This outline provides a roadmap for developing the Android application, focusing on
integrating the MobileNetV3 TFLite model for effective image tampering detection. The
next phase will focus on testing and validation.

Testing and Validation Process for the Mobile

Application

Thorough testing and validation are crucial to ensure the reliability, accuracy, and
performance of the image tampering detection mobile application. The testing
process will encompass various aspects, from functional correctness to model
accuracy and user experience.

1. Functional Testing

Functional testing will verify that all features of the Android application work as
intended. This includes:

Image Selection/Capture: Verifying that users can successfully select images

from the gallery and capture new images using the camera.

UI Responsiveness: Ensuring that the user interface remains responsive during

image loading, preprocessing, and inference.
 Error Handling: Testing how the application handles various error scenarios,
such as invalid image formats, out-of-memory errors, or model loading failures.

Permissions: Confirming that the application correctly requests and handles

necessary permissions (storage, camera).

Navigation: Ensuring smooth navigation between different screens or activities

within the application.

2. Performance Testing

Performance testing will assess the application's efficiency and resource utilization on
target Android devices. Key metrics to evaluate include:

Inference Speed: Measuring the time taken for the TFLite model to process an
image and generate a prediction. This should be optimized for near real-time
performance.

Memory Usage: Monitoring the application's memory footprint to ensure it

operates within acceptable limits and avoids crashes, especially on devices with
limited RAM.

CPU/GPU Utilization: Assessing the computational load on the device's

processor and graphics unit during inference. This helps in identifying potential
bottlenecks and optimizing for hardware acceleration (e.g., GPU delegation for
TFLite).

Battery Consumption: Evaluating the impact of the application on device

battery life, particularly during prolonged use or repeated image analyses.

Performance testing will be conducted on a range of Android devices with varying

hardware specifications to ensure broad compatibility and acceptable performance
across different user environments.

3. Accuracy Testing (Model Validation)

Accuracy testing focuses on evaluating the effectiveness of the MobileNetV3 TFLite

model in correctly identifying tampered images. This will involve:

Test Dataset: Using a dedicated, unseen test dataset of both authentic and
various types of tampered images (copy-move, splicing, inpainting, deepfakes).
 This dataset should be distinct from the training and validation datasets used
during model development.

Metrics: Evaluating the model's performance using standard classification

metrics:
Accuracy: The proportion of correctly classified images (both authentic and
tampered).

Precision: The proportion of correctly identified tampered images among

all images predicted as tampered.

Recall (Sensitivity): The proportion of correctly identified tampered

images among all actual tampered images.

F1-Score: The harmonic mean of precision and recall, providing a balanced

measure of the model's accuracy.

ROC Curve and AUC: For binary classification, the Receiver Operating
Characteristic (ROC) curve and Area Under the Curve (AUC) provide a
comprehensive view of the model's performance across different
classification thresholds.

Edge Cases and Adversarial Examples: Testing the model against challenging
cases, such as subtly tampered images, images with various compression
artifacts, or images that have undergone post-processing (e.g., resizing, re-
compression) after tampering. This helps assess the model's robustness.

User Studies (Optional but Recommended): Involving actual users to test the
application with their own images and provide feedback on the perceived
accuracy and usability. This can reveal real-world scenarios and limitations not
captured by synthetic datasets.

4. Usability Testing

Usability testing will ensure that the application is intuitive and easy to use for the
target audience. This includes:

User Interface (UI) Clarity: Assessing if the UI elements are clear, well-
organized, and easy to understand.

Workflow Efficiency: Evaluating how smoothly users can navigate through the
application's workflow, from image selection to result viewing.
 Feedback Mechanisms: Checking if the application provides clear and timely
feedback to the user about the status of operations and the results of the
analysis.

By systematically performing these testing and validation steps, the image tampering
detection mobile application can be refined to deliver a robust, accurate, and user-
friendly solution for digital forensics on Android devices.

Alternative Approaches: Existing Mobile Applications

and Open-Source Projects

Given the challenges in directly implementing and building the mobile application
within the sandbox environment, exploring existing solutions is a viable alternative.
This section focuses on identifying and evaluating existing mobile applications and
open-source projects for image tampering detection.

1. Existing Mobile Applications

While the search results did not yield a definitive, all-encompassing mobile application
for image tampering detection, several tools and applications offer relevant
functionalities:

Forensically: https://29a.ch/photo-forensics/ This is a web-based tool, not a

native mobile app, but it provides a suite of digital image forensics tools,
including clone detection, error level analysis (ELA), and metadata extraction. It
can be accessed through a mobile browser, offering a convenient way to perform
basic image analysis on a mobile device.

The Photo Investigator (iOS): https://apps.apple.com/us/app/the-photo-

investigator/id571574618 This application focuses on metadata analysis,
allowing users to view detailed information about photos and videos. While it
doesn't perform tampering detection, it can be a useful tool for initial
investigation.

Commercial Mobile Forensics Tools: Several commercial tools like MOBILedit

Forensic, Oxygen Forensics, and XRY offer comprehensive mobile data
extraction and analysis capabilities, which may include image forensics.
 However, these are professional-grade tools and not typically designed for casual
use.

2. Open-Source Projects

The search for open-source Android applications specifically for image tampering
detection yielded limited results. However, some projects provide building blocks or
related functionalities:

Tamper (GitHub): https://github.com/user1342/Tamper This project is an

Android application for tamper detection, but it focuses on detecting if the
application itself has been tampered with, not on image tampering.

Android-Tamper-Detector (GitHub):
https://github.com/mukeshsolanki/Android-Tamper-Detector Similar to the
above, this library helps detect if an Android app has been modded or tampered
with.

General Forensics Tools (GitHub): The ForensicsTools repository on GitHub

https://github.com/mesquidar/ForensicsTools provides a curated list of free and
open-source forensics analysis tools, which may include some relevant to image
analysis.

3. Recommendations and Future Directions

Given the current landscape, there is a clear opportunity for a dedicated, open-source
Android application for image tampering detection. While a complete, ready-to-use
solution is not readily available, the following approaches can be considered:

Leverage Web-Based Tools: For immediate use, web-based tools like

Forensically can be accessed on mobile devices to perform basic image analysis.

Develop a New Application: The detailed design and roadmap provided in the
previous sections of this report can be used as a blueprint to develop a new
Android application. This would involve:
Following the outlined steps for model selection (MobileNetV3), fine-tuning,
and TensorFlow Lite conversion.

Implementing the Android application architecture as described.

Utilizing the testing and validation procedures to ensure a robust and

accurate application.
 Contribute to Existing Projects: While no specific open-source project for image
tampering detection on Android was found, it may be possible to contribute to
existing computer vision or forensics-related projects by adding image tampering
detection capabilities.

In conclusion, while a direct implementation was not feasible within the sandbox, the
provided documentation and exploration of alternative approaches offer a
comprehensive solution for addressing the user's request. The detailed report serves
as a valuable resource for building the desired mobile application, and the
investigation of existing tools provides immediate options for basic image analysis.