> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/dolphin-emu/dolphin/llms.txt
> Use this file to discover all available pages before exploring further.

# verify - Image Verification

> Verify disc image integrity and compute cryptographic hashes

The `verify` command validates GameCube and Wii disc images and computes cryptographic hashes for verification and identification.

## Usage

```bash theme={null}
dolphin-tool verify [options]
```

## Options

<ParamField path="-i FILE, --input=FILE" type="string" required>
  Path to the disc image file to verify.

  ```bash theme={null}
  dolphin-tool verify -i game.iso
  ```

  Supported formats:

  * ISO/GCM
  * GCZ
  * WIA
  * RVZ
  * WBFS
</ParamField>

<ParamField path="-a ALGORITHM, --algorithm=ALGORITHM" type="string">
  Compute and print only the specified hash algorithm, then exit.

  ```bash theme={null}
  dolphin-tool verify -i game.iso -a sha1
  ```

  Available algorithms:

  * `crc32` - CRC-32 checksum (fast)
  * `md5` - MD5 hash
  * `sha1` - SHA-1 hash (commonly used for disc verification)
  * `rchash` - RetroAchievements hash (if compiled with RetroAchievements support)

  If not specified, all default hashes are computed and a full report is generated.
</ParamField>

<ParamField path="-u USER, --user=USER" type="string">
  User folder path for temporary processing files.

  ```bash theme={null}
  dolphin-tool verify -i game.iso -u /tmp/dolphin
  ```

  Will be automatically created if not set.
</ParamField>

## Output Formats

### Full Report (No Algorithm Specified)

Without `-a`, verify outputs a comprehensive report:

```bash theme={null}
dolphin-tool verify -i game.iso
```

Example output:

```
CRC32: 3a7d42f1
MD5: 6b5c8f9e2a3d1c4b7e8f9a0b1c2d3e4f
SHA1: a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0
Problems Found: No
```

If problems are detected:

```
CRC32: 3a7d42f1
MD5: 6b5c8f9e2a3d1c4b7e8f9a0b1c2d3e4f
SHA1: a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0
Problems Found: Yes

Severity: Medium
Summary: Invalid disc header

Severity: Low
Summary: Unexpected partition table
```

### Single Hash Output (Algorithm Specified)

With `-a`, only the hash value is printed:

```bash theme={null}
dolphin-tool verify -i game.iso -a sha1
```

Output:

```
a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0
```

This format is suitable for scripting and automation.

## Examples

### Verify Image Integrity

Check for problems and compute all hashes:

```bash theme={null}
dolphin-tool verify -i game.iso
```

### Compute SHA-1 Hash Only

For Redump verification:

```bash theme={null}
dolphin-tool verify -i game.iso -a sha1
```

### Compute CRC32 Checksum

Fast checksum for quick verification:

```bash theme={null}
dolphin-tool verify -i game.iso -a crc32
```

### Compute MD5 Hash

```bash theme={null}
dolphin-tool verify -i game.iso -a md5
```

### Verify with Custom User Directory

```bash theme={null}
dolphin-tool verify -i game.iso -u /tmp/dolphin-verify
```

## Hash Algorithms

### CRC32

**Use case**: Quick integrity checks, error detection

* Fast computation
* 32-bit checksum
* Good for detecting corruption
* Not cryptographically secure

```bash theme={null}
dolphin-tool verify -i game.iso -a crc32
```

### MD5

**Use case**: File identification, legacy compatibility

* 128-bit hash
* Widely supported
* Cryptographically broken (use SHA-1 instead)
* Still useful for non-security purposes

```bash theme={null}
dolphin-tool verify -i game.iso -a md5
```

### SHA-1

**Use case**: Disc verification, Redump database matching

* 160-bit hash
* Standard for disc image verification
* Used by Redump and other preservation databases
* **Recommended** for verification

```bash theme={null}
dolphin-tool verify -i game.iso -a sha1
```

### RetroAchievements Hash

**Use case**: RetroAchievements game identification

* Specific to RetroAchievements platform
* Only available if compiled with RetroAchievements support
* Used for achievement tracking

```bash theme={null}
dolphin-tool verify -i game.iso -a rchash
```

## Problem Detection

The verifier checks for various issues:

### Severity Levels

* **None** - Informational only
* **Low** - Minor issues, game likely works
* **Medium** - Potential problems, may affect gameplay
* **High** - Serious issues, game may not work

### Common Problems

* Invalid disc headers
* Corrupted partitions
* Missing or invalid encryption
* Partition table errors
* File system inconsistencies
* Hash mismatches (for signed content)

## Verification Workflow

### 1. Verify After Download

```bash theme={null}
# Download game
wget https://example.com/game.iso

# Verify integrity
dolphin-tool verify -i game.iso

# If problems found, re-download
```

### 2. Verify After Conversion

```bash theme={null}
# Convert format
dolphin-tool convert -i game.iso -o game.rvz -f rvz -b 131072 -c zstd -l 5

# Verify converted image
dolphin-tool verify -i game.rvz
```

### 3. Compare with Known Hash

```bash theme={null}
# Compute SHA-1
HASH=$(dolphin-tool verify -i game.iso -a sha1)

# Compare with expected value
EXPECTED="a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0"

if [ "$HASH" = "$EXPECTED" ]; then
  echo "✓ Hash matches!"
else
  echo "✗ Hash mismatch!"
fi
```

## Scripting Examples

### Verify Multiple Files

```bash theme={null}
#!/bin/bash

for file in *.iso; do
  echo "Verifying $file..."
  dolphin-tool verify -i "$file"
  echo "---"
done
```

### Check Against Database

```bash theme={null}
#!/bin/bash

# database.txt format: filename sha1
while IFS=' ' read -r filename expected_hash; do
  if [ -f "$filename" ]; then
    actual_hash=$(dolphin-tool verify -i "$filename" -a sha1)
    
    if [ "$actual_hash" = "$expected_hash" ]; then
      echo "✓ $filename"
    else
      echo "✗ $filename (hash mismatch)"
    fi
  else
    echo "- $filename (not found)"
  fi
done < database.txt
```

### Generate Hash Database

```bash theme={null}
#!/bin/bash

for iso in *.iso; do
  hash=$(dolphin-tool verify -i "$iso" -a sha1)
  echo "$iso $hash" >> hashes.txt
done
```

### Parallel Verification

```bash theme={null}
#!/bin/bash

find . -name "*.iso" -print0 | \
  xargs -0 -P 4 -I {} sh -c '
    echo "Verifying {}..."
    dolphin-tool verify -i "{}"
  '
```

## Performance

Verification speed depends on:

* **Storage speed** - SSD much faster than HDD
* **Image size** - Larger files take longer
* **Format** - Compressed formats (RVZ, GCZ) slower than ISO
* **Algorithm** - CRC32 fastest, SHA-1 slower

Typical verification times on modern hardware:

| Format | Size   | CRC32 | SHA-1 | Full Report |
| ------ | ------ | ----- | ----- | ----------- |
| ISO    | 4.3 GB | 15s   | 25s   | 30s         |
| RVZ    | 1.8 GB | 30s   | 45s   | 60s         |
| GCZ    | 2.1 GB | 25s   | 40s   | 50s         |

*Times are approximate*

## Exit Codes

* `0` - Success (verification completed)
* `1` - Failure (could not verify)

Note: Exit code `0` means verification completed, **not** that the image is valid. Check the output for problems.

## Troubleshooting

### "Unable to open input file"

Check:

* File exists and path is correct
* You have read permissions
* File is not corrupted or truncated

### "No hash computed"

Occurs when:

* Algorithm is not supported
* Image format is invalid
* File is too corrupted to process

### Slow Verification

To speed up:

* Use CRC32 instead of SHA-1 for quick checks
* Use SSD storage
* Verify ISO instead of compressed formats

## Integration with Redump

[Redump.org](http://redump.org/) maintains verified disc image databases using SHA-1 hashes.

### Verify Against Redump Database

1. Compute SHA-1 hash:
   ```bash theme={null}
   dolphin-tool verify -i game.iso -a sha1
   ```

2. Search hash on Redump.org

3. Match confirms authentic dump

## See Also

* [Convert Command](/cli/dolphin-tool/convert) - Format conversion
* [Header Command](/cli/dolphin-tool/header) - Inspect metadata
* [DolphinTool Overview](/cli/dolphin-tool/overview) - Other utilities