# Digital Forensics Engineering

> An engineering-oriented course covering the digital-evidence life cycle from first response and forensic acquisition to file systems, memory, network, mobile and cloud analysis, tool validation, correlation, and reporting.

- Author: Muhammet Ali Köker
- Language: en
- Canonical: https://alikoker.com.tr/en/digital-forensics-engineering
- Translation: https://alikoker.com.tr/adli-bilisim-muhendisligi
- Published: 2020-09-01T12:00:00+03:00
- Modified: 2026-09-23T23:21:42+03:00
- Verified: 2026-09-23T21:05:00+03:00
- Type: article

Digital forensics engineering is not merely the act of “finding data” after an incident. Its objective is to establish a repeatable engineering process for **identifying, preserving, acquiring, examining, analyzing, interpreting, and reporting** potential digital evidence. A technically interesting artifact is not automatically strong evidence. Provenance, acquisition method, transformations applied to the data, and the ability of an independent examiner to reproduce the result are as important as the finding itself.

This course treats first response, forensic acquisition, hashing, file-system and deleted-data analysis, network and memory forensics, mobile devices, cloud evidence, timeline reconstruction, tool validation, and technical reporting as one evidence lifecycle. Legal authority, procedure, and admissibility vary by jurisdiction, so the discussion is technical rather than legal advice. For adjacent topics, see [Information Technology Law](/en/information-technology-law), [HTS Analysis](/en/hts-analysis), and [Cybersecurity Engineering](/en/cybersecurity-engineering).

## Unit 1: Digital Evidence and the Engineering Foundation

### The evidence lifecycle

A useful high-level model is:

```text
preparation
  ↓
identification
  ↓
preservation
  ↓
acquisition
  ↓
examination
  ↓
analysis and interpretation
  ↓
reporting
  ↓
independent review / reproduction
```

The sequence is not a one-way pipeline. Analysis may reveal a previously unknown source that requires another acquisition. Every stage should therefore record its inputs, outputs, assumptions, and side effects.

### Why digital evidence is fragile

Digital data can be copied with extraordinary fidelity, but it can also be modified by ordinary system behavior. Mounting a disk read-write, opening an application, synchronizing a mobile device, installing an acquisition agent, or allowing a cloud log to age beyond its retention period can change what remains available.

The correct preservation question is therefore not simply “did anyone touch the device?” It is: **which action can modify which evidence, and is that modification justified and documented?**

### States of data

Evidence can be considered in three broad states:

- **Data at rest:** persistent storage on disks, SSDs, removable media, and service storage.
- **Data in use:** RAM, running processes, open handles, decrypted keys, session tokens, and live application state.
- **Data in transit:** packets, flows, messages, and protocol transactions moving through a network.

The state affects acquisition. A powered-off disk may permit bit-level imaging, while a full-disk-encryption key that exists only in memory may disappear when power is removed.

## Unit 2: First Response, Scene Handling, and Secure Transport

### The goal of first response

First response should stabilize the situation and preserve future investigative options rather than immediately perform deep analysis. Personnel safety, legal authority, physical security, device state, network state, and likely evidence sources must be considered together.

Preparation should include more than a tool kit:

- scope and authority,
- team roles,
- expected device and network types,
- estimated data volume,
- clean target storage,
- power and interface adapters,
- write blockers,
- synchronized clocks and documentation forms,
- transport and physical protection,
- special risks such as encryption, remote wipe, anti-forensics, or hazardous environments.

### Powered on or powered off?

There is no universal rule that says “always shut it down” or “never shut it down.” Volatile data value, encryption, remote-access risk, malware behavior, open sessions, and organizational procedure determine the decision.

Any live response changes state. Commands consume memory, tools create processes, logs advance, and caches evolve. When live acquisition is justified, the examiner should record commands, tool versions, timestamps, and known side effects. Current SWGDE guidance similarly emphasizes least-invasive live collection and explicit documentation of changes created by the collection itself.

### Order of volatility

Different sources disappear at different rates. A conceptual order is:

```text
processor / transient execution state
        ↓
RAM, processes, active connections
        ↓
temporary files and live logs
        ↓
persistent file systems
        ↓
backups and remote copies
```

This is not an absolute recipe. A remotely retained cloud log can be more perishable than a local disk. Priority follows the incident-specific risk of loss.

### Modeling the technical scene

A digital scene is not limited to a physical room. A desktop, wireless access point, network storage system, printer queue, mobile device, online account, and remote service can all be evidence surfaces of the same event. The goal of first response is therefore not to seize the largest possible number of devices, but to determine **which systems generate which evidence sources and how those sources relate to one another**.

Before deployment, a technical response plan should answer at least the following questions:

- What device classes and approximate data volumes are expected?
- Which systems are likely to be powered on?
- Is there a risk from encryption, remote wiping, synchronization, or central management?
- What is known about network topology, server roles, and responsible technical personnel?
- Which adapters, write blockers, power supplies, or special interfaces may be required?
- Which evidence sources are volatile enough to deserve priority?
- Is there sufficient capacity for secure transport and temporary storage?

Preparation also means validating the tools before they reach the scene. A tool being installed is not enough; its version, configuration, time source, licensing state, and output format should be known.

### Scene security and documentation

Context loss is as serious for digital evidence as it is for physical evidence. Before equipment is moved, responders should document screen state, cabling, open applications, attached peripherals, serial numbers, network connections, and visible error messages. Photographs, video, diagrams, and evidence labels serve different purposes and should be used together.

A photograph of a device by itself may be insufficient. The relationship between an external drive and a particular USB port, or between a switch port and a particular cable, can later become important for ownership and timeline questions. Documentation should preserve a chain such as:

```text
physical location
    -> device identity
        -> connection/port
            -> logical source
                -> acquired forensic image
```

### Decision model for live systems

Powered-on versus powered-off handling is a central first-response decision. Modern systems make that choice especially consequential: full-disk encryption, keys in RAM, authentication tokens, ephemeral containers, and active cloud sessions can disappear at shutdown. At the same time, every command executed on a live host changes its state.

There is therefore no universal rule that a live system should always be powered off or always examined live. The decision depends on:

- the value of volatile evidence,
- system criticality,
- encryption state,
- risk of remote action,
- active malicious processes,
- legal and organizational authority,
- side effects of the collection tool,
- operational impact of interruption.

Live collection should record the expected side effects of each action. Capturing memory changes memory; enumerating network connections invokes system functions and may create logs. This does not invalidate the method. The relevant requirement is that the change be **predictable, bounded, and documented**.

### Order of volatility and acquisition priority

Order of volatility should not be memorized as simply “RAM before disk.” Different sources decay at different rates:

```text
CPU/register/cache state
        ↓
running processes and RAM
        ↓
network sessions / ARP / routing / socket state
        ↓
temporary files and buffered logs
        ↓
local persistent storage
        ↓
remote logs / backups / archives
```

The incident can change this priority. During a network intrusion, short-lived connection state may be more valuable than disk imaging. On a physically failing storage device, repeated power cycles can reduce the chance of successful recovery.

### First response by device class

#### Desktops and laptops

Power state, screen contents, attached storage, network connections, and active sessions should be documented. A powered-off device is not booted merely for convenience. A live device should not be powered down until encryption and volatile-evidence needs have been evaluated. External storage should receive an independent evidence identity.

#### Servers

Server intervention can have a much larger operational effect than work on a single-user computer. Virtual machines, containers, shared storage, RAID, centralized logging, and concurrent user sessions are separate sources. Removing a physical disk is not always the correct acquisition method; service availability and consistency must be considered.

#### Network devices

Routers, switches, firewalls, and wireless access points can maintain running state that differs from persistent configuration. ARP caches, NAT tables, connection tables, DHCP state, clock/NTP status, and short-lived log buffers may disappear after shutdown. A configuration backup alone does not describe an active incident.

#### Printers, scanners, copiers, and similar systems

Multifunction devices can hold print jobs, address books, authentication information, scan destinations, local storage, and network logs. They should not be ignored simply because they are categorized as peripherals.

#### Portable and embedded systems

Cameras, navigation devices, media players, smart watches, IoT devices, and industrial controllers may require methods that differ from desktop forensics. Serial/JTAG access, storage removal, or vendor-specific protocols may be necessary. Because hardware intervention can be irreversible, lower-impact methods should be evaluated first.

### Packaging, transport, and environmental risk

Antistatic protection, impact resistance, and radio-frequency shielding serve one underlying principle: transport must not introduce a new physical or logical effect. Mechanical shock, electrostatic discharge, moisture, extreme temperature, and unauthorized wireless communication are different threat classes.

A Faraday bag is not a universal solution for mobile devices. Loss of signal can increase power consumption, heat, and battery depletion. Modern devices also expose multiple radios such as cellular, Wi-Fi, Bluetooth, NFC, and eSIM-associated functions. Isolation should be validated for the device and situation.

## Unit 3: Evidence Identity, Chain of Custody, and Integrity

### Evidence identity

An evidence item should be traceable through information such as:

```text
evidence identifier
source device / account / service
serial number or logical identifier
collector
acquisition time and time zone
location
acquisition method
tool and version
output files
hash values
subsequent transfers
```

Chain of custody is not merely a signed form. It is the continuous record of **who possessed the evidence, when, for what purpose, and in what condition**.

### What a hash proves—and what it does not

A cryptographic hash is a digest of a particular byte sequence. It is therefore useful for demonstrating that a forensic copy still contains the same bytes as the acquired source representation.

```text
source bytes --hash--> H1
copy bytes   --hash--> H2
H1 == H2  -> strong bit-level integrity check
```

A hash is not the same as a **digital signature**. A digital signature binds integrity to a private-key operation and an identity context; a hash alone only summarizes data. It also does not prove who created a file or whether the represented event is legally authentic.

MD5 and SHA-1 were historically common in forensic workflows, but their collision resistance is no longer suitable for new cryptographic designs. SHA-256 or another current digest should normally be preferred. Historical evidence carrying MD5 values is not automatically invalid; the overall validation context and any additional hashes matter.

## Unit 4: Forensic Acquisition, Imaging, and Write Protection

### Physical and logical acquisition

**Physical acquisition** attempts to capture raw storage at a lower level and may expose unallocated space, deleted content, and file-system structures.

**Logical acquisition** obtains objects exposed by a file system, application, operating system, or service API. For modern mobile platforms, SaaS systems, and cloud environments, logical acquisition may be the only practical and authorized method.

```text
physical acquisition -> broader raw representation
logical acquisition  -> richer semantic context
```

Neither is universally superior. Encryption, device state, access method, storage technology, and investigative objective determine fitness for purpose.

### Write protection

A write blocker reduces the risk of accidental writes to source media. It is an important control, but the presence of a device does not by itself validate the workflow. Interface type, bridge hardware, operating-system behavior, source technology, and tool version should be tested and documented.

SSDs complicate assumptions inherited from magnetic disks. Controller firmware, TRIM, garbage collection, and wear leveling can make the physical persistence of deleted data unpredictable.

### Forensic images

A defensible acquisition record should include:

- source description,
- start and completion time,
- read errors and retries,
- acquisition extent,
- output format,
- tool version and settings,
- hash values,
- operator notes.

Forensic containers such as E01 or AFF4 can carry metadata and segmentation; raw images are simpler. Format selection should be driven by interoperability, validation, compression, integrity, and long-term accessibility rather than habit.

### Evidence acquisition strategies

“Forensic imaging” describes a family of acquisition strategies rather than one operation:

- **Physical acquisition:** capture of the widest feasible addressable storage space.
- **Logical acquisition:** collection of objects exposed by a file system, application, or supported API.
- **File-system acquisition:** collection that preserves directory structure, metadata, and files.
- **Targeted acquisition:** selective acquisition under time, volume, or authority constraints.

Targeted acquisition is efficient but can be incomplete if a new question emerges later. Physical acquisition may provide a broader evidence surface, but it is not always feasible on modern mobile platforms with hardware-backed encryption and secure execution environments.

### Sector-level, file-level, and content-targeted copies

Block-level acquisition can preserve unallocated space and remnants that are invisible to the active file system. File-level acquisition can be entirely appropriate when only live files and metadata are required, but it limits deleted-data analysis. The method should follow the investigative question:

```text
question: is deleted/unallocated data relevant?
        |
       yes -> prefer block/physical acquisition where feasible
        |
        no -> logical acquisition may be sufficient
```

### Engineering meaning of write protection

A write blocker is not simply a box placed between a drive and a workstation. The trust boundary lies between source media and the examination environment. Hardware write blockers provide a common, testable control; software-based blocking requires greater trust in the operating system, driver stack, and configuration.

A write-protection method should be tested for:

- correct device recognition,
- successful read operations,
- rejection of write commands,
- reporting of blocked or failed operations,
- support for the storage interface in use.

SATA, SAS, NVMe, USB, UFS, and embedded interfaces do not necessarily share the same blocking mechanism.

### Image formats and acquisition logs

Raw images (`raw/dd`) provide a simple representation. E01/EWF-style forensic containers can add segmentation, compression, metadata, and integrity information. Format choice should consider tool validation, interoperability, storage cost, and the downstream examination chain.

An acquisition log should record at least:

- source and destination identity,
- serial number and capacity,
- interface and write-protection method,
- tool and version,
- start and end times,
- time zone,
- read errors and bad sectors,
- source/output hashes,
- operator and evidence number.

### Read errors and damaged media

On damaged media, repeated attempts can make recovery worse. Physical condition should be assessed first. Mechanical disks showing abnormal sound, electronics damage, or surface failure may require specialized recovery and clean-room procedures. Aggressive retry policies can further stress marginal media.

The acquisition tool should record unreadable sectors, retry policy, and skipped regions. A successful output hash does not prove that the original source was fully readable; it proves that the resulting byte sequence has a stable identity after acquisition.

### Hashing, verification, and evidence identity

A hash value does not carry the entire evidential meaning of an item. Two verification questions should be separated:

1. **Acquisition verification:** whether the output corresponds to the source that was intended to be acquired.
2. **Preservation verification:** whether an already acquired object has changed since its hash was recorded.

SHA-256 and other current cryptographic hash functions are preferred for modern workflows. MD5 and SHA-1 remain visible in legacy tools and case formats; they should not be selected as the sole security mechanism for a new design. Multiple hashes can be retained when interoperability with historical tooling requires them.

## Unit 5: Storage Media, File Systems, Deleted Data, and Timelines

### Content and metadata

A file is more than its payload. File systems may provide:

- name and path,
- inode/MFT-like records,
- size,
- permissions,
- creation/modification/access timestamps,
- allocation state,
- alternate streams or extended attributes.

Deletion often removes metadata references before every underlying byte is overwritten. However, SSD behavior and TRIM make the old claim that deleted data is always recoverable increasingly unreliable.

### File carving

When file-system metadata is absent, carving searches raw data using file signatures and structural rules. See [Digital Forensic File Carving Algorithms](/en/data-carving-algorithm-for-digital-forensics) for a deeper treatment.

A carved object does not have the same provenance as a normal file-system record. Fragmentation, false positives, truncated objects, and internal-format validation must be considered.

### Timeline reconstruction

A reliable timeline should combine independent sources:

```text
file-system timestamps
+ operating-system logs
+ browser history
+ application data
+ network records
+ identity-provider events
+ remote-service logs
= correlated timeline
```

Time zones, daylight-saving rules, clock skew, NTP adjustments, virtual-machine snapshots, and manually changed clocks can all alter interpretation. A timestamp is an observation; chronology is an inference built from multiple sources.

### Storage Media and File-System Engineering

The meaning of digital evidence does not come from file contents alone. The behavior of the storage medium, partition layout, file system, controller layer, and operating system determines how much historical data can remain and how timestamps should be interpreted. A forensic examiner should therefore ask not only “what is on the disk?” but also “how does this system place, modify, and delete data?”

### HDDs, SSDs, and removable media

Magnetic disks provide a relatively stable logical view of sectors, although remapping, error correction, controller caches, and firmware still abstract the physical medium. SSDs introduce a much stronger abstraction. Flash Translation Layers, wear leveling, garbage collection, and TRIM mean that a logical block address exposed to the operating system does not map permanently to one NAND location.

That distinction changes expectations around deleted data. On a magnetic disk, directory metadata may be removed while content remains until overwritten. On an SSD, TRIM and later garbage collection can make the same assumption unreliable. Neither “deleted files are always recoverable” nor “TRIM means nothing can ever be recovered” is a sound rule. Controller behavior, operating system, file system, interface, encryption, and elapsed time all matter.

USB storage, memory cards, optical media, and external enclosures also add interface layers. USB-to-SATA bridges, card readers, and hardware-encryption enclosures may hide device geometry or health information. The acquisition method must expose enough of the underlying device for the forensic objective.

### Separating partition, volume, and file-system layers

A physical medium may contain several abstraction layers:

```text
physical device
  -> partition scheme
      -> partition / logical volume
          -> file system
              -> file / directory / metadata
                  -> application artifact
```

Partition metadata such as MBR/GPT is not the same thing as NTFS, FAT/exFAT, ext-family, or other file-system metadata. Even when a forensic suite hides these details, the examiner must know which layer produced a finding.

### Unallocated space, slack, and file-system metadata

Space not allocated to active files may retain fragments of earlier content. Cluster or file slack can exist where allocated storage exceeds logical file length. Modern file systems complicate this simple model with compression, sparse files, copy-on-write, journaling, snapshots, and other allocation strategies.

Metadata is more than a filename and a timestamp. File identifiers, parent relationships, permissions, alternate streams, journals, extended attributes, and transaction records can contribute to event reconstruction. Timestamp semantics are file-system-specific; two fields both labeled “modified” do not necessarily represent the same event.

### Journaling and copy-on-write effects

Journaling file systems record metadata, and sometimes data changes, to improve consistency. Those records can expose traces of earlier operations, but a journal entry by itself does not prove a specific user action. Copy-on-write and snapshot mechanisms can likewise preserve historical states that are invisible in the active namespace.

### RAID, NAS, and SAN environments

RAID and networked storage require separate acquisition reasoning. In such environments, imaging one disk is often insufficient. RAID level, member order, stripe size, parity layout, controller metadata, and missing members affect reconstruction.

```text
one member-disk image
   !=
forensic view of the RAID logical volume
```

A NAS appliance can expose evidence in its operating system, account database, protocol logs, and snapshots as well as its disks. In a SAN, LUN mapping, storage-network events, and the host file system are separate layers. When a live service cannot be stopped, storage snapshots may be appropriate, but their consistency guarantees and creation time must be documented.

### File signature versus extension

A filename extension is user-interface metadata, not proof of a file format. Magic bytes, structural validation, and content parsing can be combined. Looking only at a few initial bytes is also insufficient because polyglot files, embedded content, and damaged headers can mislead simple classifiers.

A stronger analysis model is:

```text
extension -> initial hypothesis
signature/structure -> format validation
parser -> semantic interpretation
context -> evidential meaning
```

## Unit 6: Operating-System, Application, Identity, and Communications Artifacts

### Windows

Typical Windows sources include Registry hives, Event Logs, Prefetch, LNK files, Jump Lists, browser databases, NTFS metadata, Volume Shadow Copies, and user-profile artifacts. An examiner should understand the mechanism that creates an artifact before attributing it to a human action.

### Linux

Linux evidence may include `journal` data, syslog files, authentication records, shell histories, package databases, cron/systemd definitions, home directories, process state, and file-system metadata. In containerized environments, host, orchestrator, and container logs can have different retention and clock behavior.

### macOS

APFS, Unified Logging, plist files, user Library data, Spotlight metadata, and cloud synchronization require assumptions different from legacy HFS+ analysis. Tool support must be matched to the relevant macOS and APFS versions.

### Browsers, e-mail, and messaging

Browser history, cookies, cache, local storage, downloads, and profile databases can reconstruct user activity. Synchronized profiles require care because a record visible on one device may have originated elsewhere.

For e-mail and messaging, headers, server logs, message identifiers, delivery traces, and client-side copies should be correlated. A screenshot is weaker than the underlying structured record when the latter can be preserved.

### Linking examination purpose to method

Forensic examination is broader than criminal investigation. Technical examination can support:

- crime and misuse investigations,
- vulnerability and unauthorized-access analysis,
- reconstruction of user activity,
- relationship analysis across people/accounts/devices,
- dispute and incident resolution,
- incident response and root-cause analysis.

The purpose changes evidence priority. Shell history and application artifacts may dominate a user-activity investigation, while authentication logs, network telemetry, and connection records can be more important in an intrusion case.

### Operating-system logs

Logs are products of logging mechanisms; they are not direct copies of reality. An examiner should understand source configuration, retention, rotation, time source, and the possibility of missing records.

On Windows, channel, provider, Event ID, timestamp, and event payload should be interpreted together. On Linux, journald, syslog-family sources, authentication logs, kernel messages, and service-specific logs may provide different views. Application and web-server logs can use time and formatting conventions independent of the operating system.

### Windows Registry and configuration artifacts

The Registry can describe user profiles, installed applications, services, recently used objects, autostart locations, device history, and system configuration. Registry hives such as `NTUSER.DAT`, `SYSTEM`, `SOFTWARE`, and `SAM` remain conceptually useful, although exact key locations and semantics can change across Windows versions.

A Registry entry is not automatically proof of direct user action. The operating system, installer, or application may create it. Registry findings should therefore be correlated with artifacts such as Prefetch, LNK files, Jump Lists, event logs, browser history, or file-system timestamps.

### Installed software and execution traces

Package records, installed-program lists, services, startup entries, and application directories describe system capability. “Installed” and “executed” are different claims. Evidence of execution may require process artifacts, Prefetch-like traces, application logs, shell history, or user-profile data.

### Deleted data and file recovery

Deletion semantics vary among file systems. Some systems mark metadata entries as free; some return blocks to allocation structures; SSDs may propagate TRIM information to the storage layer. The common assumption that a deleted file is always recoverable is false.

Recovery can use two broad techniques:

- reconstruction from file-system metadata,
- file carving based on signatures or content structure.

Carving may not recover the original filename, path, or exact length, and fragmented files can be reassembled incorrectly.

### Snapshots, shadow copies, and prior versions

Volume Shadow Copy and similar mechanisms can preserve earlier states of files. A snapshot is not the same thing as a backup. Its creation time, retention behavior, and the mapping between file versions and snapshots should be understood. Virtual-machine and file-system snapshots require the same kind of temporal reasoning.

### Hex-level examination

A hex viewer exposes raw bytes without relying entirely on a high-level parser. It is valuable for validating file signatures, partition tables, slack space, damaged structures, and carving output. Hex is not self-explanatory: byte order, character encoding, and the relevant binary structure must still be known.

### Metadata analysis

File-system metadata, document metadata, media EXIF data, and application-database metadata belong to different layers. Even a phrase such as “creation time” can have different meanings at each layer. Copying, exporting, messaging, or cloud synchronization may rewrite timestamps.

### Web history and browser artifacts

Browser examination extends beyond URL history. Downloads, cache, cookies, local/session storage, session state, form data, and extension data can answer different questions. Private-browsing modes do not guarantee that no trace exists elsewhere; DNS caches, network telemetry, and remote service logs may still be relevant.

### E-mail and instant messaging

The visible sender field is different from the transport path. RFC headers, `Message-ID`, `Received` lines, MIME structure, attachments, and server logs should be considered together. A local mail archive, webmail service, and mobile client may each retain different fragments of the same account history.

Messaging evidence can span message databases, media caches, notification artifacts, backups, and cloud synchronization. End-to-end encryption does not imply that decrypted data is absent from endpoint devices.

### Indexing and keyword search

Indexing reduces search cost on large data sets, but the index is itself a transformation. Tokenization, character encoding, stop-word behavior, language, normalization, and unsupported file formats all affect results. “No hit” in an index is therefore not equivalent to “the data does not exist.”

A search set can contain words, e-mail addresses, domains, usernames, telephone numbers, IP addresses, hashes, regular expressions, and case-specific identifiers. Overly broad searches create noise; overly narrow searches can miss evidence.

### Categorization and filtering

Filtering by file type, known hash set, MIME type, size, time range, user, or directory can reduce the examination space. Known-good hash sets are useful for eliminating common files, but a hash identifies one exact byte sequence; a different build of the same application will have a different hash.

### Booting or virtualizing a forensic image

Booting a disk image in a virtual machine can help reproduce the user's environment, but a verified master image should not be mounted writeable. A derived working copy or copy-on-write layer should absorb changes.

Virtual hardware may not reproduce TPM, GPU, licensing, drivers, network, and clock behavior exactly. Booting is therefore complementary to artifact analysis rather than a replacement for it.

### Intersection with malware analysis

A suspicious file's hash, signature, and path are only starting points. Static analysis examines structure, imports, strings, and code; dynamic analysis observes behavior in a controlled environment. Executing suspicious software on evidential systems is not a validation method.

Malware findings should be connected to process, network, persistence, file-creation, Registry, and credential-access artifacts and then placed on the incident timeline.

### Digital Identity, Communications, and Location Artifacts

User activity is increasingly distributed across browsers, email, messaging clients, mobile apps, and remote services rather than confined to one computer's file system. These sources provide rich context but also carry a high risk of over-attribution.

### Browser artifacts

History, cache, cookies, downloads, form data, local storage, and session state answer different questions. A URL in browser history does not by itself prove an intentional visit by a particular person; redirects, prefetching, embedded resources, and synchronization can create records.

A safer reasoning chain is:

```text
artifact -> this browser profile contains a record for the resource
correlation -> time + download + cache + session support one event
attribution -> additional identity evidence is needed for the physical actor
```

### Email headers and MIME structure

The displayed `From` field is not sufficient source authentication. Transport headers, Message-ID, Received chains, timestamps, SPF/DKIM/DMARC results when available, server logs, and account-session evidence can be correlated. MIME structure determines how attachments and embedded objects are represented.

### Messaging applications and SQLite

Desktop and mobile applications frequently use SQLite or similar embedded databases. Active tables, WAL/journal files, and deleted pages may reflect different historical states. Schema versions can change across application updates, so a parser that assumes fixed columns may silently produce wrong results. Critical fields should be checked against raw data when necessary.

### Location data

GPS coordinates, Wi-Fi access-point observations, cellular identifiers, image EXIF, application location histories, and IP geolocation have different error models. None automatically proves that a person was physically present. Device possession, sensor source, synchronization, and shared accounts must be considered.

### Social-platform and remote-account evidence

Social-media evidence should not be reduced to screenshots. When available, platform exports, account identifiers, content identifiers, timestamps, URLs, relationship records, and acquisition method should be preserved together. Screenshots are useful for visual context; structured data is more useful for search, timeline analysis, and correlation.

## Unit 7: Live Response, Memory, and Malware Examination

### Memory acquisition

RAM can contain:

- processes and threads,
- active network connections,
- injected code,
- command history,
- decryption keys,
- session tokens,
- malware components absent from disk.

Memory acquisition itself modifies the machine. The acquisition tool’s footprint, driver requirements, platform compatibility, and generated artifacts should be documented.

### Live versus post-mortem examination

Live response gains volatile evidence but creates state changes. Post-mortem examination is more controlled but loses RAM, active sessions, and some decrypted content. The choice is risk-based, not ideological.

### Malware analysis

Hashes and antivirus signatures are only the start. Static analysis can inspect format, imports, strings, code structure, and embedded resources. Dynamic analysis observes process creation, file and registry changes, persistence, and network behavior in an isolated environment. Original evidence should not be executed directly when a verified working copy can be used.

### Live Response, Memory, and Volatile Evidence

Examining a running system inevitably changes it. Executing a command creates processes, allocates memory, may write logs, and changes caches. The objective of live response is therefore not “zero change” but the smallest necessary, measurable, and justified change.

### Deciding on live acquisition

Live acquisition can be especially valuable when:

- full-disk encryption is currently unlocked,
- memory may contain keys, sessions, or process state,
- fileless or memory-resident malware is suspected,
- active network connections and listening sockets matter,
- shutdown would cause greater evidential or operational loss.

Conversely, uncontrolled scripts or unvalidated tools can alter evidence unnecessarily. The decision should follow pre-established authority and procedure rather than improvisation at the scene.

### The evidential surface of memory

A memory image can contain:

- process and thread structures,
- loaded modules,
- open files and objects,
- network sockets,
- command or application buffers,
- authentication artifacts,
- some cryptographic keys,
- kernel objects and drivers,
- injected or concealed code.

A string found in memory should not automatically be attributed to a user. It may originate from an application cache, file cache, network packet, or another process. Structural context and correlation with disk or network artifacts are required.

### Live-response ordering

A generic sequence can be expressed as:

```text
time source
 -> users / sessions
 -> processes and services
 -> network connections
 -> open files / mounts
 -> memory acquisition
 -> critical configuration and logs
 -> persistent-media acquisition
```

This is not a universal fixed order. Volatility, platform, threat, and business-continuity constraints change priorities. What matters is that the selected sequence and its rationale are recorded.

### Measuring tool impact

A live-response tool changes the host through its binary, libraries, drivers, and output operations. It should be:

- obtained from a trusted source,
- identified by hash,
- version-recorded,
- characterized on test systems,
- configured so output does not unnecessarily modify source media.

Output may be written to separate media or a trusted network target. Network transfer itself creates connections and traffic, so that effect belongs in the activity log.

### Time, drift, and timezone

An incorrect device clock can distort an entire timeline. Local time, UTC offset, timezone configuration, NTP state, and observed drift should be recorded. Rather than “correcting” the source clock during acquisition, the discrepancy should be documented and normalized during analysis.

## Unit 8: Network, Wireless, and Mobile Forensics

### Packets, flows, and logs are different evidence

A PCAP may preserve packet payload and protocol details. NetFlow/IPFIX-style flow records describe communication relationships and volumes with far less content. Firewall, DNS, proxy, VPN, and identity logs add product-specific semantic events.

```text
packet -> protocol detail
flow   -> relationship and volume
log    -> product interpretation
```

These sources are complementary rather than interchangeable.

Wireshark is useful for protocol dissection and filtering, but correct interpretation requires protocol knowledge. Capture filters, display filters, TCP reassembly, NAT, proxies, tunnels, and encrypted traffic belong to different layers of analysis.

### Encrypted traffic

TLS does not eliminate network forensics. Payload may be hidden while endpoints, timing, volume, certificate metadata, DNS, and host-side logs still support correlation. TLS 1.3 and newer privacy mechanisms change which metadata is observable, so assumptions must be verified against the actual protocol and network architecture.

### Mobile Device Forensics

Modern mobile devices combine strong encryption, secure boot, hardware-backed keys, application sandboxes, and cloud synchronization. The old model of “image all flash storage” is not universally available.

Acquisition can be viewed as a spectrum:

```text
manual observation
  ↓
logical export
  ↓
file-system acquisition
  ↓
physical / low-level acquisition
```

Lower-level acquisition is not automatically more informative. Encrypted raw storage may expose less useful evidence than a semantically rich file-system acquisition performed while the device is legitimately unlocked.

First response should consider lock state, battery, network connectivity, remote-wipe risk, USB state, and active sessions. Radio isolation can be useful but may also change power consumption and device behavior.

NIST SP 800-101 Rev. 1 treats validation, preservation, acquisition, examination, analysis, and reporting as connected parts of mobile forensic practice.

### Network capture and the Wireshark model

Tool-independent packet analysis has three stages:

1. **Capture:** collect packets at the correct interface and observation point.
2. **Dissection:** interpret Ethernet/IP/TCP/UDP and higher-layer protocols.
3. **Analysis:** apply filters, stream reconstruction, statistics, and correlation to the case question.

Capture filters and display filters are not equivalent. A capture filter discards data before it is stored; a display filter changes only what is shown. Aggressive capture filtering can create irreversible evidence loss.

Typical questions include:

```text
which DNS names did this endpoint query?
which TCP sessions show abnormal retransmission?
which host contacted unexpected external destinations?
which TLS sessions share a common SNI or certificate property?
```

### Packets, flows, and sessions

A single packet is often insufficient context. Reassembling a TCP stream can reveal an application conversation. NetFlow/IPFIX-style records can show peers, ports, volume, and time without retaining full content. PCAP provides high detail at high storage cost; flow records trade detail for longer retention.

### Wireless artifacts

Wireless analysis can combine saved SSID/BSSID state, connection times, DHCP records, and access-point logs. A MAC address is not a definitive person identity; modern operating systems may randomize MAC addresses.

### Mobile-device evidence surface

Modern mobile forensics extends far beyond contacts and SMS. Evidence can exist in:

- application sandboxes,
- SQLite/Realm-style databases,
- keychain/keystore stores,
- notification data,
- media and thumbnail caches,
- location and sensor data,
- cloud backups,
- embedded web content,
- eSIM and network configuration.

Historical platforms such as Symbian, BlackBerry, Windows Mobile, MeeGo, and Bada remain useful for understanding the evolution of mobile forensics. Current examinations must select methods according to the present security model and device version.

### Mobile acquisition levels

A rough hierarchy is:

```text
manual observation
   ↓
logical backup/API
   ↓
file-system acquisition
   ↓
physical/bootloader-level acquisition
   ↓
hardware methods such as JTAG or chip-off
```

A lower layer is not automatically better. Hardware methods can be destructive, costly, or ineffective against modern encryption. The preferred method is the least invasive technique that can answer the examination question.

### SIM and subscriber data

A SIM/UICC can expose subscription identifiers, network parameters, and limited user data. Most modern communication history is not stored on the SIM but on the device and within application/cloud stores. SIM data should be correlated with device artifacts, carrier records, and account information.

### Mobile media

Content analysis and metadata analysis are separate. EXIF timestamps and location can be rewritten or stripped. A thumbnail can remain after the original file has disappeared. Messaging applications may recompress images and remove metadata.

## Unit 9: Cloud, Remote-Service, and Distributed-System Evidence

### Cloud and Remote-Service Evidence

Cloud investigations often cannot center on a disk image. Relevant evidence can reside in:

- provider audit logs,
- object storage,
- SaaS exports,
- API responses,
- identity systems,
- snapshots and backups,
- management-plane activity.

Provider-derived evidence should record tenant/account identity, request time, API or export version, format, provider integrity metadata, time zone, and retention policy. SWGDE’s 2025 cloud-evidence guidance explicitly recognizes that provider-specific implementations make a single universal acquisition procedure impractical.

Multi-tenant infrastructure also means that seizing a physical disk may be impossible or inappropriate. Logical provenance and provider records therefore become central to the evidence chain.

### Cloud evidence as a multi-layer system

A “disk image” is often unavailable or incomplete in cloud environments. Evidence may instead consist of audit logs, object versions, IAM events, API calls, snapshots, serverless-function logs, container layers, or SaaS exports. Provider-side timestamps and account/tenant identity are essential context.

### Time and identity in distributed systems

Correlating logs across nodes requires explicit handling of clock drift, NTP synchronization, and time zones. Comparing displayed local times directly can create a false event order. Request IDs, trace IDs, session IDs, user/device identity, and network tuples can support correlation.

## Unit 10: Search, Indexing, Correlation, and Large-Evidence-Set Analysis

### Search is an engineering operation

Keyword search depends on encoding, Unicode normalization, case rules, language, regular expressions, tokenization, compression, and index coverage. To reproduce a search, record:

```text
query
search mode
encoding
case policy
regular expression, if any
scope
excluded data
tool and version
```

### Correlation

Strong conclusions often emerge from independent artifacts rather than a single record. A claim that a file was copied to removable media, for example, may be supported by USB-device history, file timestamps, LNK or recent-item artifacts, user-session records, and system logs.

The report should still distinguish observation from inference.

### Relationship analysis

Accounts, devices, IP addresses, phone numbers, file hashes, and timestamps can be modeled as a graph. Identity resolution requires caution: a shared IP, NAT address, common device, or reused number does not automatically represent one individual.

### Timeline engineering

A forensic timeline is not merely sorted file `mtime` values. Different artifacts represent different temporal semantics:

- event occurrence time,
- log-write time,
- synchronization time,
- copy/export time,
- parser-derived time.

Time zone and daylight-saving changes must be normalized without losing the original representation. A defensible timeline retains both source type and original time semantics for each event.

### Correlation: from artifact to event model

A strong inference often emerges when independent sources support the same hypothesis. A claim that a USB device was used, for example, can be supported by:

```text
Registry device history
   +
setup/device logs
   +
LNK / Jump List artifacts
   +
file-system timestamps
   +
user-session timing
        ↓
stronger event model
```

Disagreement is equally valuable. It can indicate clock problems, deletion, another user, synchronization behavior, or parser error.

### Relationship analysis — deeper treatment

Graphs can connect people, devices, accounts, IP addresses, telephone numbers, files, and events. An edge should have a precise meaning. Sharing an IP address or Wi-Fi network does not by itself establish a direct human relationship.

```text
account A --logged into--> device X
device X  --connected to--> IP Y
account A --messaged--> account B
```

A generic “related to” edge hides important evidential semantics.

### Forensic scalability

Terabyte-scale evidence sets and millions of files make exhaustive deep parsing expensive. A staged pipeline can preserve rigor while allocating expensive work effectively:

1. evidence inventory,
2. fast metadata extraction,
3. known-file filtering,
4. time/user scoping,
5. indexing,
6. targeted deep parsing,
7. manual verification.

Filtering criteria should be retained so that the examination scope can be reproduced later.

### Examination Workflow for Large Evidence Sets

Modern cases can involve hundreds of devices, cloud exports, mailboxes, packet captures, and mobile backups. The problem is not only data volume; it is reducing the search space without losing scope or provenance.

### Known-file sets and hash-based reduction

Cryptographic hashes allow exact byte-identical files to be compared efficiently. Validated known-good operating-system or application files can be filtered, while known-malicious or otherwise significant hashes can be prioritized.

The limitation is clear: a one-bit modification changes a cryptographic hash completely. Similar-image, document, or transformed-media discovery may therefore use perceptual hashes or feature-based fingerprints. Such similarity functions must not be confused with cryptographic integrity verification.

### Archives, containers, and nested data

One file may contain many others: archives, mailbox containers, virtual disks, office documents, mobile backups, or databases. Recursive extraction needs explicit resource budgets because malformed or hostile inputs can consume excessive CPU, memory, or storage.

Every derived object should preserve its origin chain:

```text
source image
 -> container
    -> archive
       -> embedded file
          -> parsed artifact
```

That chain lets a reportable finding be traced back to raw evidence.

### Indexing, encoding, and search

Text search is not merely scanning ASCII or UTF-8. UTF-16, legacy encodings, compressed content, PDF/Office structures, and database fields require format-aware parsing. Keyword sets should:

- derive from case hypotheses,
- include context to control false positives,
- define case and language behavior,
- account for performance and traceability when using regular expressions.

A search-engine hit is not itself an evidential conclusion. Location within the source object, provenance, time, and identity context must still be examined.

### Deduplication and near-duplicate analysis

Exact duplicates can overwhelm a large examination. Cryptographic-hash deduplication is a strong first step. However, identical content with different metadata or provenance may still be evidentially distinct. A system should retain the relationship “one content object, N source occurrences” rather than discarding origin information.

### Derived evidence and export

Thumbnails, converted images, extracted text, decompressed objects, database exports, and screenshots of virtualized systems are not the original evidence. They are derived artifacts. For important transformations it is useful to retain:

- source identity,
- tool and version,
- parameters,
- output hash,
- transformation time.

This supports independent verification and later reprocessing.

## Unit 11: Tool Ecosystem, Validation, Repeatability, and Quality Assurance

### Tool output is an interpretation

A clean table produced by a forensic suite is an interpretation of underlying bytes. Unsupported versions, parser defects, changed schemas, or misunderstood timestamp semantics can produce convincing but incorrect results.

Critical findings benefit from layered verification:

```text
raw source
  ↓
tool A parsing
  ↓
independent tool / manual verification
  ↓
semantic consistency check
```

The NIST Computer Forensics Tool Testing program publishes testing methods and reports for forensic functions. The NIST Tool Catalog is useful for discovering tools and capabilities, but catalog inclusion does not mean that NIST has independently validated a particular product.

### Repeatability and reproducibility

- **Repeatability:** obtaining comparable results with the same method and conditions.
- **Reproducibility:** enabling an independent examiner or environment to verify the result.

ISO/IEC 27042 emphasizes continuity, validity, repeatability, reproducibility, and sufficient documentation for independent scrutiny.

### Anti-forensics

Timestomping, log deletion, secure erasure, steganography, packing, obfuscation, file-system manipulation, and deliberately fabricated artifacts may reduce visibility. Absence of an artifact is not equivalent to proof that an event did not occur. Collection gaps and retention limits must be reported.

### Tool ecosystem and historical products

Write blockers from vendors such as Tableau and WiebeTech, forensic suites such as FTK, EnCase, X-Ways, OSForensics, Nuix, Belkasoft, Autopsy/Sleuth Kit, and mobile tools such as XRY, UFED, and Oxygen are historically and operationally useful examples, but **a product name is not a proof of correctness**.

A forensic tool should instead be evaluated by capability:

- acquisition and verification,
- file-system parsing,
- deleted-data recovery and carving,
- indexing and search,
- Registry/OS artifact parsing,
- e-mail and messaging analysis,
- mobile extraction and parsing,
- network analysis,
- memory analysis,
- reporting and export.

Parser behavior can change between versions. Critical findings should be verified with a second tool, raw data, or an independent method when feasible.

### Validation before operational use

A forensic laboratory should maintain known-answer test sets. A test image can contain known files, deleted objects, timestamps, multiple file systems, and malformed structures. Expected results are documented in advance and regression tests are run after tool updates.

```text
known input
   ↓
tool + version + configuration
   ↓
compare with expected output
   ↓
document limitations if results diverge
```

### Generalizing the FTK/forensic-suite workflow

FTK-style tabs and imaging procedures can be generalized into the common workflow of a forensic suite. A typical suite:

- adds evidence sources to a case,
- parses file systems,
- classifies files by type and metadata,
- builds a search index,
- searches keywords and structured values,
- presents specialized views for e-mail and media,
- bookmarks relevant items,
- exports selected objects and reports.

Convenience should not hide the underlying data model. If a suite marks a file as “Deleted,” the examiner should understand which file-system structure supports that interpretation before reporting it.

### Laboratory quality system

Quality assurance begins long before the final report. A mature forensic laboratory maintains:

- hardware and software inventories,
- version control,
- known-answer test images,
- validated standard operating procedures,
- time-source checks,
- hash and chain-of-custody controls,
- peer review,
- deviation/error records,
- regression testing after tool updates.

This turns individual expertise into a repeatable organizational capability.

## Unit 12: Encryption, Passwords, and Evidence Accessibility

### Encryption, Passwords, and Accessibility

Integrity and accessibility are different problems. An encrypted image can be acquired and hashed correctly while its contents remain unavailable.

Authorized recovery strategies may include:

- logical acquisition from an already-unlocked session,
- volatile key material,
- enterprise key management,
- backups or synchronized replicas,
- password-recovery workflows,
- service-provider exports.

Password-search feasibility depends on the KDF, work factor, password distribution, and available hardware. “A GPU can crack any password” is not a technically defensible claim.

### Password and encryption limits

When encrypted content is found, the encryption layer should first be identified: full disk, partition, file, archive, application database, or communication protocol. Password-recovery activity must remain within legal and resource constraints. GPU-assisted guessing rates depend heavily on the password scheme; generic claims that encryption is “breakable” or “unbreakable” are not technically useful.

A mounted encrypted volume on a live system can make volatile evidence especially important because keys or decrypted content may disappear at shutdown.

## Unit 13: Reporting, Expert Boundaries, and Defensible Findings

### Reporting and the Limits of Expert Interpretation

A good forensic report is not a collection of screenshots. A reader should be able to determine:

1. what material was examined,
2. which tools and methods were used,
3. how source integrity was protected,
4. which observations were made,
5. which inferences were drawn,
6. which alternative explanations remain,
7. what the limitations are,
8. how another examiner can reproduce the result.

### Separate observation from inference

```text
Observation:
  A record exists with timestamp 2026-09-23T10:15:04+03:00.

Interpretation:
  The record supports the possibility that the application was active then.

Overclaim:
  The user definitely opened the application at that exact moment.
```

The discipline of digital forensics lies partly in resisting the third sentence.

### Evidence confidence

A useful mental model is:

```text
source reliability
× acquisition integrity
× parser correctness
× contextual correlation
× disciplined interpretation
```

This is not a numerical probability formula. It is a reminder that a weak link should reduce the strength of the stated conclusion.

### Structure of a reportable finding

A technical finding should separate four elements:

1. **Source:** which evidence item and location?
2. **Observation:** what was present in the raw or parsed data?
3. **Method:** what tool or procedure produced the observation?
4. **Interpretation:** what does the observation mean for the case?

For example:

```text
Source        : Disk image D1, user-profile artifact
Observation   : A record exists at 14:32:11Z
Method        : Parsed with Tool A; raw record verified independently
Interpretation: Supports possible interaction by the relevant account
Limit         : Does not independently identify the physical user
```

### Daubert, ACPO principles, and methodological transfer

The Daubert standard and ACPO principles are useful in their respective legal and methodological contexts. They belong to particular legal contexts and should not be treated as universal legal rules. Their enduring technical lessons are methodological: minimize unnecessary changes to original data, document necessary changes, use competent personnel, make methods explainable, and preserve enough provenance for independent review.

## Unit 14: Scalable, Deterministic, and Auditable Forensic Architecture

### Scalable and Auditable Forensic Architecture

At scale, digital forensics becomes a pipeline across acquisition, parsing, indexing, correlation, analyst review, and reporting rather than a purely manual desktop workflow. Performance matters, but determinism and auditability matter more.

### Separating stages in the pipeline

Raw evidence and derived information should remain distinct:

```text
immutable raw evidence
   -> verified working copy
      -> parser/decoder output
         -> index and features
            -> correlation
               -> analyst finding
                  -> report
```

Raw evidence remains unchanged. Reprocessing with a newer parser version can produce a separate derived dataset so that tool-version effects are measurable.

### Parallelism and deterministic results

Independent objects can often be parsed in parallel, but concurrency should not make semantics or error handling nondeterministic. Job identity, source hash, parser version, configuration, and deterministic normalization help ensure that the same input under the same version produces the same evidential meaning.

### Fault isolation

One malformed object should not stop an entire case. Parser failures should be:

- bound to the source object,
- classified and recorded,
- isolated from unrelated processing,
- eligible for retry or independent verification when significant.

A silently skipped object is more dangerous than an explicit failure because analysts may assume the corpus is complete.

### Audit trail and access control

In a multi-user laboratory, it should be possible to determine who opened evidence, performed exports, changed findings, and released reports. Operational audit logs do not replace chain of custody, but they strengthen it.

Case-scoped authorization, least privilege, sensitive-content classification, and export policy keep the forensic platform itself from becoming a new disclosure channel.

### Performance versus correctness

Pre-indexing, hash filtering, parallel parsing, and incremental timeline construction can provide substantial performance gains. Optimization must not discard provenance or validation. A useful priority order is:

```text
correctness and integrity
 -> traceability
    -> repeatability
       -> coverage
          -> performance
```

## Engineering Checklist

```text
1. verify authority and scope
2. inventory potential sources
3. rank volatility and loss risk
4. preserve source state
5. justify the acquisition method
6. verify integrity
7. separate source evidence from working copies
8. record tool and version
9. independently verify critical findings
10. validate clock and time-zone semantics
11. separate observations from interpretations
12. state limitations
13. make the report reproducible
```

Digital forensics engineering is therefore less about memorizing a large collection of tools than about **controlling the transformation chain from source evidence to defensible conclusion**. Tools, file systems, mobile platforms, and cloud services will change. Authority, integrity, traceability, validation, reproducibility, and disciplined interpretation remain the durable principles.

## References

- Carrier, B. *File System Forensic Analysis*. Addison-Wesley, 2005.
- Casey, E. *Digital Evidence and Computer Crime: Forensic Science, Computers, and the Internet*. 3rd ed., Academic Press, 2011.
- ISO/IEC 27037:2012. *Guidelines for identification, collection, acquisition and preservation of digital evidence*. https://www.iso.org/standard/44381.html
- ISO/IEC 27041:2015. *Guidance on assuring suitability and adequacy of incident investigative method*. https://www.iso.org/standard/44405.html
- ISO/IEC 27042:2015. *Guidelines for the analysis and interpretation of digital evidence*. https://www.iso.org/standard/44406.html
- ISO/IEC 27043:2015. *Incident investigation principles and processes*. https://www.iso.org/standard/44407.html
- NIST. *Computer Forensics Tool Testing Program (CFTT).* https://www.nist.gov/itl/ssd/software-quality-group/computer-forensics-tool-testing-program-cftt
- NIST. *Computer Forensics Tools & Techniques Catalog.* https://toolcatalog.nist.gov/
- NIST SP 800-86. *Guide to Integrating Forensic Techniques into Incident Response*. https://csrc.nist.gov/pubs/sp/800/86/final
- NIST SP 800-101 Rev. 1. *Guidelines on Mobile Device Forensics*. https://csrc.nist.gov/pubs/sp/800/101/r1/final
- Scientific Working Group on Digital Evidence. *Best Practices for Digital Evidence Collection*, Version 2.0, 2025. https://www.swgde.org/documents/published-complete-listing/18-f-002-2-0/
- Scientific Working Group on Digital Evidence. *Best Practices for Digital Evidence Acquisition, Preservation, and Analysis from Cloud Service Providers*, Version 1.1, 2025. https://www.swgde.org/documents/published-complete-listing/23-f-004-best-practices-for-digital-evidence-acquisition-preservation-and-analysis-from-cloud-service-providers/

## Cite This Work

Köker, M. A. (2020). Digital Forensics Engineering. alikoker.com.tr. https://alikoker.com.tr/en/digital-forensics-engineering

- BibTeX: https://alikoker.com.tr/en/digital-forensics-engineering.bib
- RIS: https://alikoker.com.tr/en/digital-forensics-engineering.ris
- CSL-JSON: https://alikoker.com.tr/en/digital-forensics-engineering.csl.json