Tutorial

Create and manage disk images on your Roundfleet devices for efficient data packaging, software distribution, and system deployment. This tutorial covers disk image creation from folders, advanced formatting options, encryption, compression, and enterprise-scale image management workflows.

Understanding Disk Images

Disk images are file containers that replicate the exact structure and content of storage volumes, providing powerful capabilities for enterprise deployment:

Benefits of Disk Images

• Software Distribution - Package applications and configurations for deployment
• Data Backup - Create portable snapshots of folder contents
• System Deployment - Standardize configurations across multiple devices
• Secure Transport - Encrypted images for sensitive data transfer
• Version Control - Maintain different versions of software packages
• Network Efficiency - Compressed images reduce transfer time

Disk Image Types

• .dmg - Apple Disk Image (primary format)
• .iso - ISO 9660 format for cross-platform compatibility
• .sparseimage - Sparse images that grow as needed
• .sparsebundle - Bundle format for network storage

Basic Disk Image Creation

Simple Folder to Disk Image

#!/bin/bash

# Create basic disk image from folder
SOURCE_FOLDER="$1"
IMAGE_NAME="$2"
OUTPUT_PATH="$3"

if [[ -z "$SOURCE_FOLDER" || -z "$IMAGE_NAME" || -z "$OUTPUT_PATH" ]]; then
    echo "❌ Usage: $0 <source_folder> <image_name> <output_path>"
    echo "Example: $0 /Users/Shared MyImage /Users/username/Documents"
    exit 1
fi

# Validate source folder exists
if [[ ! -d "$SOURCE_FOLDER" ]]; then
    echo "❌ Source folder does not exist: $SOURCE_FOLDER"
    exit 1
fi

# Create output directory if it doesn't exist
mkdir -p "$OUTPUT_PATH"

echo "💿 Creating disk image from folder..."
echo "Source: $SOURCE_FOLDER"
echo "Image name: $IMAGE_NAME"
echo "Output: $OUTPUT_PATH/$IMAGE_NAME.dmg"

# Create the disk image
if hdiutil create -fs HFS+ -srcfolder "$SOURCE_FOLDER" -volname "$IMAGE_NAME" "$OUTPUT_PATH/$IMAGE_NAME.dmg"; then
    echo "✅ Disk image created successfully"
    
    # Get image size
    IMAGE_SIZE=$(du -h "$OUTPUT_PATH/$IMAGE_NAME.dmg" | cut -f1)
    echo "Image size: $IMAGE_SIZE"
    
    # Get source folder size for comparison
    SOURCE_SIZE=$(du -sh "$SOURCE_FOLDER" | cut -f1)
    echo "Source folder size: $SOURCE_SIZE"
else
    echo "❌ Failed to create disk image"
    exit 1
fi

Advanced Disk Image Creation

#!/bin/bash

# Advanced disk image creation with options
create_advanced_disk_image() {
    local source_folder="$1"
    local image_name="$2"
    local output_path="$3"
    local filesystem="${4:-HFS+}"
    local compression="${5:-UDBZ}"
    local encryption="${6:-false}"
    
    if [[ ! -d "$source_folder" ]]; then
        echo "❌ Source folder not found: $source_folder"
        return 1
    fi
    
    mkdir -p "$output_path"
    
    echo "💿 Creating advanced disk image..."
    echo "Source: $source_folder"
    echo "Filesystem: $filesystem"
    echo "Compression: $compression"
    echo "Encryption: $encryption"
    
    # Build hdiutil command
    local cmd="hdiutil create"
    cmd="$cmd -fs $filesystem"
    cmd="$cmd -srcfolder '$source_folder'"
    cmd="$cmd -volname '$image_name'"
    
    # Add compression if specified
    if [[ "$compression" != "none" ]]; then
        cmd="$cmd -format $compression"
    fi
    
    # Add encryption if requested
    if [[ "$encryption" == "true" ]]; then
        cmd="$cmd -encryption AES-256"
        cmd="$cmd -stdinpass"
        echo "🔐 Encryption enabled - you will be prompted for a password"
    fi
    
    cmd="$cmd '$output_path/$image_name.dmg'"
    
    # Execute command
    if [[ "$encryption" == "true" ]]; then
        echo "Enter password for disk image encryption:"
        read -s password
        echo "$password" | eval "$cmd"
    else
        eval "$cmd"
    fi
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Advanced disk image created successfully"
        
        # Display image information
        echo ""
        echo "=== Image Information ==="
        hdiutil imageinfo "$output_path/$image_name.dmg" | grep -E "Format|Compressed|Encrypted|Checksum"
        
        return 0
    else
        echo "❌ Failed to create disk image"
        return 1
    fi
}

# Usage examples
# create_advanced_disk_image "/Users/Shared" "SharedData" "/tmp" "HFS+" "UDBZ" "false"
# create_advanced_disk_image "/Applications/MyApp.app" "MyApp" "/tmp" "HFS+" "UDZO" "true"

Filesystem and Format Options

Supported Filesystems

#!/bin/bash

# Display available filesystem and format options
show_disk_image_options() {
    echo "=== Available Filesystems ==="
    echo "HFS+     - Mac OS Extended (default)"
    echo "HFS+J    - Mac OS Extended (Journaled)"
    echo "HFSX     - Mac OS Extended (Case-sensitive)"
    echo "JHFS+X   - Mac OS Extended (Case-sensitive, Journaled)"
    echo "MS-DOS   - FAT32 (compatible with Windows)"
    echo "UDF      - Universal Disk Format"
    echo "APFS     - Apple File System (macOS 10.13+)"
    echo ""
    
    echo "=== Image Format Options ==="
    echo "UDRO     - Read-only, smaller size"
    echo "UDCO     - ADC compressed (obsolete)"
    echo "UDZO     - zlib compressed (most common)"
    echo "UDBZ     - bzip2 compressed (better compression)"
    echo "ULFO     - lzfse compressed (macOS 10.11+)"
    echo "ULMO     - lzma compressed"
    echo "UFBI     - Entire device"
    echo "SPARSE   - Sparse image (grows as needed)"
    echo "SPARSEBUNDLE - Sparse bundle (network friendly)"
    echo ""
    
    echo "=== Encryption Options ==="
    echo "AES-128  - 128-bit AES encryption"
    echo "AES-256  - 256-bit AES encryption (recommended)"
}

# Create disk image with specific options
create_custom_disk_image() {
    local source="$1"
    local name="$2"
    local output="$3"
    local fs="$4"
    local format="$5"
    local encrypt="$6"
    
    echo "Creating custom disk image with:"
    echo "  Filesystem: $fs"
    echo "  Format: $format"
    echo "  Encryption: $encrypt"
    
    local cmd="hdiutil create -fs '$fs' -format '$format'"
    
    if [[ "$encrypt" != "none" ]]; then
        cmd="$cmd -encryption '$encrypt' -stdinpass"
    fi
    
    cmd="$cmd -srcfolder '$source' -volname '$name' '$output/$name.dmg'"
    
    if [[ "$encrypt" != "none" ]]; then
        echo "Enter encryption password:"
        read -s password
        echo "$password" | eval "$cmd"
    else
        eval "$cmd"
    fi
}

# Example usage
# show_disk_image_options
# create_custom_disk_image "/path/to/folder" "MyImage" "/output/path" "HFS+" "UDBZ" "AES-256"

Batch Disk Image Operations

Batch Image Creation

#!/bin/bash

# Batch create disk images from multiple folders
batch_create_disk_images() {
    local base_path="$1"
    local output_dir="$2"
    local filesystem="${3:-HFS+}"
    local format="${4:-UDBZ}"
    
    if [[ ! -d "$base_path" ]]; then
        echo "❌ Base path not found: $base_path"
        return 1
    fi
    
    mkdir -p "$output_dir"
    
    echo "🔄 Starting batch disk image creation..."
    echo "Base path: $base_path"
    echo "Output directory: $output_dir"
    echo "Filesystem: $filesystem"
    echo "Format: $format"
    echo ""
    
    local success_count=0
    local failed_count=0
    local total_size=0
    
    # Process each subdirectory
    find "$base_path" -type d -mindepth 1 -maxdepth 1 | while read -r folder; do
        local folder_name=$(basename "$folder")
        local image_path="$output_dir/${folder_name}.dmg"
        
        echo "Processing: $folder_name"
        
        # Skip if image already exists
        if [[ -f "$image_path" ]]; then
            echo "  ⏭️  Image already exists, skipping"
            continue
        fi
        
        # Create disk image
        if hdiutil create -fs "$filesystem" -format "$format" \
           -srcfolder "$folder" -volname "$folder_name" \
           "$image_path" >/dev/null 2>&1; then
            
            local size=$(du -h "$image_path" | cut -f1)
            echo "  ✅ Created successfully ($size)"
            ((success_count++))
            
            # Add to total size calculation
            local size_bytes=$(du -b "$image_path" | cut -f1)
            total_size=$((total_size + size_bytes))
        else
            echo "  ❌ Failed to create image"
            ((failed_count++))
        fi
    done
    
    echo ""
    echo "=== Batch Operation Summary ==="
    echo "Successful: $success_count"
    echo "Failed: $failed_count"
    echo "Total size: $(numfmt --to=iec $total_size)"
}

# Usage example
# batch_create_disk_images "/Users/Shared/Projects" "/tmp/project_images" "HFS+" "UDBZ"

Image Verification and Analysis

#!/bin/bash

# Verify and analyze disk images
verify_disk_image() {
    local image_path="$1"
    
    if [[ ! -f "$image_path" ]]; then
        echo "❌ Image file not found: $image_path"
        return 1
    fi
    
    echo "🔍 Verifying disk image: $(basename "$image_path")"
    
    # Basic image information
    echo ""
    echo "=== Basic Information ==="
    echo "File size: $(du -h "$image_path" | cut -f1)"
    echo "File type: $(file "$image_path" | cut -d: -f2- | xargs)"
    
    # Detailed image information
    echo ""
    echo "=== Detailed Image Information ==="
    hdiutil imageinfo "$image_path" | grep -E "Format|Partition|Compressed|Encrypted|Checksum|Total"
    
    # Verify image integrity
    echo ""
    echo "=== Integrity Verification ==="
    if hdiutil verify "$image_path" >/dev/null 2>&1; then
        echo "✅ Image integrity verified successfully"
    else
        echo "❌ Image integrity verification failed"
        return 1
    fi
    
    # Test mount capability
    echo ""
    echo "=== Mount Test ==="
    local mount_point=$(mktemp -d)
    
    if hdiutil attach "$image_path" -mountpoint "$mount_point" -nobrowse -quiet; then
        echo "✅ Image mounts successfully"
        
        # Get volume information
        echo "Volume info: $(df -h "$mount_point" | tail -1 | awk '{print $2 " total, " $3 " used, " $4 " available"}')"
        
        # Count contents
        local file_count=$(find "$mount_point" -type f | wc -l | xargs)
        local dir_count=$(find "$mount_point" -type d | wc -l | xargs)
        echo "Contents: $file_count files, $dir_count directories"
        
        # Unmount
        hdiutil detach "$mount_point" -quiet
        rmdir "$mount_point"
    else
        echo "❌ Image failed to mount"
        rmdir "$mount_point"
        return 1
    fi
    
    echo ""
    echo "✅ Image verification completed successfully"
    return 0
}

# Batch verification
verify_multiple_images() {
    local image_dir="$1"
    
    if [[ ! -d "$image_dir" ]]; then
        echo "❌ Image directory not found: $image_dir"
        return 1
    fi
    
    echo "🔍 Verifying all disk images in: $image_dir"
    echo ""
    
    local verified=0
    local failed=0
    
    find "$image_dir" -name "*.dmg" -type f | while read -r image; do
        echo "Verifying: $(basename "$image")"
        if verify_disk_image "$image" >/dev/null 2>&1; then
            echo "  ✅ Verified"
            ((verified++))
        else
            echo "  ❌ Failed"
            ((failed++))
        fi
    done
    
    echo ""
    echo "Verification complete: $verified passed, $failed failed"
}

Enterprise Disk Image Management

#!/bin/bash

# Roundfleet Disk Image Management Tool
# Comprehensive disk image creation and management for enterprise environments

# Configuration
LOG_FILE="/var/log/roundfleet_diskimage.log"
BACKUP_DIR="/var/backups/roundfleet/images"
REPORT_DIR="/var/reports/roundfleet/images"
CONFIG_FILE="/etc/roundfleet/image_policy.conf"
TEMP_DIR="/tmp/roundfleet_images"

# Default settings
DEFAULT_FILESYSTEM="HFS+"
DEFAULT_FORMAT="UDBZ"
DEFAULT_ENCRYPTION="AES-256"
ENABLE_COMPRESSION=true
ENABLE_VERIFICATION=true
MAX_IMAGE_SIZE="10G"
CLEANUP_TEMP_FILES=true

# Logging function
log_action() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Setup directories
setup_directories() {
    for dir in "$BACKUP_DIR" "$REPORT_DIR" "$(dirname "$CONFIG_FILE")" "$TEMP_DIR"; do
        if [[ ! -d "$dir" ]]; then
            sudo mkdir -p "$dir"
            log_action "Created directory: $dir"
        fi
    done
}

# Check available disk space
check_disk_space() {
    local target_dir="$1"
    local required_space="$2"  # in bytes
    
    local available_space=$(df "$target_dir" | tail -1 | awk '{print $4}')
    available_space=$((available_space * 1024))  # Convert to bytes
    
    if [[ "$available_space" -lt "$required_space" ]]; then
        echo "❌ Insufficient disk space"
        echo "Required: $(numfmt --to=iec $required_space)"
        echo "Available: $(numfmt --to=iec $available_space)"
        return 1
    fi
    
    return 0
}

# Create enterprise disk image with full logging and validation
create_enterprise_disk_image() {
    local source_path="$1"
    local image_name="$2"
    local output_dir="$3"
    local filesystem="${4:-$DEFAULT_FILESYSTEM}"
    local format="${5:-$DEFAULT_FORMAT}"
    local encrypt="${6:-false}"
    local description="$7"
    
    log_action "Starting enterprise disk image creation: $image_name"
    
    # Validation
    if [[ ! -d "$source_path" ]]; then
        echo "❌ Source path not found: $source_path"
        log_action "ERROR: Source path not found: $source_path"
        return 1
    fi
    
    # Calculate source size
    local source_size_bytes=$(du -sb "$source_path" | cut -f1)
    local source_size_human=$(du -sh "$source_path" | cut -f1)
    
    echo "📁 Source analysis:"
    echo "  Path: $source_path"
    echo "  Size: $source_size_human ($source_size_bytes bytes)"
    
    # Check disk space (estimate 2x source size for safety)
    local estimated_space=$((source_size_bytes * 2))
    if ! check_disk_space "$output_dir" "$estimated_space"; then
        log_action "ERROR: Insufficient disk space for image creation"
        return 1
    fi
    
    # Create output directory
    mkdir -p "$output_dir"
    
    local output_path="$output_dir/$image_name.dmg"
    local start_time=$(date +%s)
    
    echo ""
    echo "💿 Creating disk image..."
    echo "  Name: $image_name"
    echo "  Filesystem: $filesystem"
    echo "  Format: $format"
    echo "  Output: $output_path"
    
    # Build command
    local cmd="hdiutil create -fs '$filesystem' -format '$format'"
    cmd="$cmd -srcfolder '$source_path' -volname '$image_name'"
    
    # Add encryption if requested
    if [[ "$encrypt" == "true" ]]; then
        cmd="$cmd -encryption '$DEFAULT_ENCRYPTION' -stdinpass"
        echo "  Encryption: Enabled ($DEFAULT_ENCRYPTION)"
    fi
    
    cmd="$cmd '$output_path'"
    
    # Execute image creation
    local creation_success=false
    
    if [[ "$encrypt" == "true" ]]; then
        echo ""
        echo "🔐 Enter password for disk image encryption:"
        read -s password
        if echo "$password" | eval "$cmd" >/dev/null 2>&1; then
            creation_success=true
        fi
    else
        if eval "$cmd" >/dev/null 2>&1; then
            creation_success=true
        fi
    fi
    
    local end_time=$(date +%s)
    local duration=$((end_time - start_time))
    
    if [[ "$creation_success" == "true" ]]; then
        local image_size_bytes=$(du -b "$output_path" | cut -f1)
        local image_size_human=$(du -h "$output_path" | cut -f1)
        local compression_ratio=$(echo "scale=2; $image_size_bytes * 100 / $source_size_bytes" | bc)
        
        echo ""
        echo "✅ Disk image created successfully"
        echo "  Creation time: ${duration}s"
        echo "  Image size: $image_size_human"
        echo "  Compression ratio: ${compression_ratio}%"
        
        # Verify image if enabled
        if [[ "$ENABLE_VERIFICATION" == "true" ]]; then
            echo ""
            echo "🔍 Verifying image integrity..."
            if hdiutil verify "$output_path" >/dev/null 2>&1; then
                echo "✅ Image verification passed"
                log_action "Image created and verified: $image_name ($image_size_human)"
            else
                echo "❌ Image verification failed"
                log_action "ERROR: Image verification failed: $image_name"
                return 1
            fi
        fi
        
        # Generate image metadata
        create_image_metadata "$output_path" "$source_path" "$description"
        
        return 0
    else
        echo "❌ Failed to create disk image"
        log_action "ERROR: Failed to create disk image: $image_name"
        return 1
    fi
}

# Create metadata file for the image
create_image_metadata() {
    local image_path="$1"
    local source_path="$2"
    local description="$3"
    
    local metadata_file="${image_path%.dmg}.json"
    
    cat > "$metadata_file" << EOF
{
    "image_name": "$(basename "$image_path")",
    "creation_date": "$(date -Iseconds)",
    "source_path": "$source_path",
    "image_path": "$image_path",
    "description": "$description",
    "file_size": $(du -b "$image_path" | cut -f1),
    "file_size_human": "$(du -h "$image_path" | cut -f1)",
    "checksum_md5": "$(md5 -q "$image_path")",
    "checksum_sha256": "$(shasum -a 256 "$image_path" | cut -d' ' -f1)",
    "format_info": $(hdiutil imageinfo "$image_path" -plist | plutil -convert json -o - -)
}
EOF
    
    echo "📄 Metadata saved: $metadata_file"
}

# Generate comprehensive image report
generate_image_report() {
    local image_dir="${1:-$BACKUP_DIR}"
    local report_file="$REPORT_DIR/image_report_$(date +%Y%m%d_%H%M%S).txt"
    
    echo "📊 Generating disk image report..."
    
    {
        echo "Roundfleet Disk Image Management Report"
        echo "Generated: $(date)"
        echo "Image Directory: $image_dir"
        echo "======================================"
        echo ""
        
        if [[ ! -d "$image_dir" ]]; then
            echo "❌ Image directory not found: $image_dir"
            return 1
        fi
        
        # Count and analyze images
        local total_images=$(find "$image_dir" -name "*.dmg" -type f | wc -l)
        local total_size_bytes=0
        local verified_count=0
        local failed_count=0
        
        echo "=== Summary ==="
        echo "Total disk images: $total_images"
        
        if [[ "$total_images" -eq 0 ]]; then
            echo "No disk images found in directory"
            return 0
        fi
        
        echo ""
        echo "=== Image Details ==="
        printf "%-30s %-10s %-15s %-10s\n" "Name" "Size" "Format" "Status"
        printf "%-30s %-10s %-15s %-10s\n" "----" "----" "------" "------"
        
        find "$image_dir" -name "*.dmg" -type f | sort | while read -r image_path; do
            local image_name=$(basename "$image_path")
            local image_size=$(du -h "$image_path" | cut -f1)
            local image_size_bytes=$(du -b "$image_path" | cut -f1)
            
            # Get format info
            local format_info=$(hdiutil imageinfo "$image_path" 2>/dev/null | grep "Format Description" | cut -d: -f2- | xargs)
            if [[ -z "$format_info" ]]; then
                format_info="Unknown"
            fi
            
            # Verify integrity
            local status="Unknown"
            if hdiutil verify "$image_path" >/dev/null 2>&1; then
                status="✅ Valid"
                ((verified_count++))
            else
                status="❌ Failed"
                ((failed_count++))
            fi
            
            printf "%-30s %-10s %-15s %-10s\n" "$image_name" "$image_size" "$format_info" "$status"
            
            total_size_bytes=$((total_size_bytes + image_size_bytes))
        done
        
        echo ""
        echo "=== Statistics ==="
        echo "Total size: $(numfmt --to=iec $total_size_bytes)"
        echo "Verified images: $verified_count"
        echo "Failed verification: $failed_count"
        echo "Average size: $(numfmt --to=iec $((total_size_bytes / total_images)))"
        
        # Storage recommendations
        echo ""
        echo "=== Recommendations ==="
        if [[ "$failed_count" -gt 0 ]]; then
            echo "⚠️  $failed_count images failed verification - investigate and recreate"
        fi
        
        if [[ "$total_size_bytes" -gt $((50 * 1024 * 1024 * 1024)) ]]; then  # 50GB
            echo "💡 Consider archiving older images to free up space"
        fi
        
        echo "💡 Regular verification recommended for critical images"
        
    } > "$report_file"
    
    echo "📊 Report saved to: $report_file"
    log_action "Image report generated: $report_file"
}

# Main execution function
main() {
    local action="${1:-help}"
    local source="${2:-}"
    local name="${3:-}"
    local output="${4:-$BACKUP_DIR}"
    
    log_action "=== Roundfleet Disk Image Management Started ==="
    
    setup_directories
    
    case "$action" in
        "create")
            if [[ -n "$source" && -n "$name" ]]; then
                create_enterprise_disk_image "$source" "$name" "$output"
            else
                echo "❌ Usage: $0 create <source_folder> <image_name> [output_dir]"
                echo "Example: $0 create /Users/Shared MyImage /tmp"
            fi
            ;;
        "batch")
            if [[ -n "$source" ]]; then
                batch_create_disk_images "$source" "$output"
            else
                echo "❌ Usage: $0 batch <base_folder> [output_dir]"
                echo "Example: $0 batch /Users/Shared/Projects /tmp/images"
            fi
            ;;
        "verify")
            if [[ -n "$source" ]]; then
                if [[ -f "$source" ]]; then
                    verify_disk_image "$source"
                elif [[ -d "$source" ]]; then
                    verify_multiple_images "$source"
                else
                    echo "❌ Path not found: $source"
                fi
            else
                echo "❌ Usage: $0 verify <image_file_or_directory>"
            fi
            ;;
        "report")
            generate_image_report "$source"
            ;;
        "info")
            if [[ -n "$source" && -f "$source" ]]; then
                echo "=== Image Information ==="
                hdiutil imageinfo "$source"
            else
                echo "❌ Usage: $0 info <image_file>"
            fi
            ;;
        "options")
            show_disk_image_options
            ;;
        "help"|*)
            echo "Roundfleet Disk Image Management Tool"
            echo "Usage: $0 [action] [options]"
            echo ""
            echo "Actions:"
            echo "  create <source> <name> [output]  - Create disk image from folder"
            echo "  batch <base_dir> [output]        - Create images from all subdirectories"
            echo "  verify <image_or_dir>            - Verify image integrity"
            echo "  report [image_dir]               - Generate comprehensive report"
            echo "  info <image_file>                - Show detailed image information"
            echo "  options                          - Show available filesystem and format options"
            echo "  help                             - Show this help message"
            echo ""
            echo "Examples:"
            echo "  $0 create /Users/Shared MyData   # Create MyData.dmg from /Users/Shared"
            echo "  $0 batch /Applications /tmp       # Create images for all apps"
            echo "  $0 verify /tmp/MyData.dmg         # Verify single image"
            echo "  $0 report /tmp                    # Generate report for all images in /tmp"
            echo ""
            echo "Configuration:"
            echo "  Default filesystem: $DEFAULT_FILESYSTEM"
            echo "  Default format: $DEFAULT_FORMAT"
            echo "  Default encryption: $DEFAULT_ENCRYPTION"
            echo "  Verification enabled: $ENABLE_VERIFICATION"
            ;;
    esac
    
    log_action "=== Roundfleet Disk Image Management Completed ==="
}

# Execute main function
main "$@"

Image Format Comparison

Security and Encryption

Encrypted Image Creation

# Create encrypted disk image with enterprise policies
create_secure_image() {
    local source="$1"
    local name="$2"
    local output="$3"
    local encryption_level="${4:-AES-256}"
    
    echo "🔐 Creating encrypted disk image..."
    echo "Encryption: $encryption_level"
    
    # Generate secure password if not provided
    if [[ -z "$IMAGE_PASSWORD" ]]; then
        echo "Enter encryption password (or set IMAGE_PASSWORD environment variable):"
        read -s IMAGE_PASSWORD
    fi
    
    echo "$IMAGE_PASSWORD" | hdiutil create \
        -fs HFS+ \
        -format UDBZ \
        -encryption "$encryption_level" \
        -stdinpass \
        -srcfolder "$source" \
        -volname "$name" \
        "$output/$name.dmg"
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Encrypted image created successfully"
        echo "🔒 Image is protected with $encryption_level encryption"
    else
        echo "❌ Failed to create encrypted image"
        return 1
    fi
}

Important Notes

• Disk Space - Ensure sufficient space for image creation (2x source size recommended)
• Performance - Compression trades size for creation/access speed
• Security - Use AES-256 encryption for sensitive data
• Compatibility - Choose appropriate filesystem for target systems
• Verification - Always verify critical images after creation
• Enterprise Deployment - Test image mounting on target systems before bulk deployment