# forensic-workstation / gcp / t0 "Quick start"
#
# A workstation for examining evidence with no route to anything live: its own
# network with the default internet route deleted, no NAT, and no external
# address. It reaches Google's APIs only through restricted.googleapis.com, and
# every other outbound connection is refused. You reach it by SSH through
# Identity-Aware Proxy.
#
# Change the four values below, then:
#   gcloud auth application-default login
#   terraform init && terraform apply
#   gcloud compute ssh forensic-workstation --zone <zone> --tunnel-through-iap
#
# Verify, inside the session:
#   curl -m 5 -sI https://example.com                  # fails: no route out
#   gcloud storage ls gs://<evidence bucket>/          # lists the evidence

locals {
  project_id      = "your-project-id"      # change me
  zone            = "us-central1-a"        # change me
  evidence_bucket = "your-evidence-bucket" # change me: such as the evidence capture template's
  analyst         = "user:you@example.com" # change me
  region          = join("-", slice(split("-", local.zone), 0, 2))
  cidr            = "10.251.0.0/24"
}

terraform {
  required_version = ">= 1.6"
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = "~> 8.0"
    }
  }
}

provider "google" {
  project = local.project_id
}

resource "google_project_service" "needed" {
  for_each           = toset(["compute.googleapis.com", "iap.googleapis.com", "dns.googleapis.com"])
  service            = each.value
  disable_on_destroy = false
}

# A new network normally gets a route to the internet. This one does not.
resource "google_compute_network" "forensics" {
  name                            = "forensics-isolated"
  auto_create_subnetworks         = false
  delete_default_routes_on_create = true
  depends_on                      = [google_project_service.needed]
}

resource "google_compute_subnetwork" "forensics" {
  name                     = "forensics-isolated"
  network                  = google_compute_network.forensics.id
  region                   = local.region
  ip_cidr_range            = local.cidr
  private_ip_google_access = true
  log_config {
    aggregation_interval = "INTERVAL_5_SEC"
    flow_sampling        = 1.0
    metadata             = "INCLUDE_ALL_METADATA"
  }
}

# The one route out: Google's restricted API range, which serves only APIs
# that VPC Service Controls can protect.
resource "google_compute_route" "restricted_apis" {
  name             = "forensics-restricted-apis"
  network          = google_compute_network.forensics.id
  dest_range       = "199.36.153.4/30"
  next_hop_gateway = "default-internet-gateway"
}

# Point every Google API name at the restricted range.
resource "google_dns_managed_zone" "googleapis" {
  name        = "forensics-googleapis"
  dns_name    = "googleapis.com."
  visibility  = "private"
  description = "Google APIs through restricted.googleapis.com only"
  private_visibility_config {
    networks {
      network_url = google_compute_network.forensics.id
    }
  }
}

resource "google_dns_record_set" "restricted" {
  managed_zone = google_dns_managed_zone.googleapis.name
  name         = "restricted.googleapis.com."
  type         = "A"
  ttl          = 300
  rrdatas      = ["199.36.153.4", "199.36.153.5", "199.36.153.6", "199.36.153.7"]
}

resource "google_dns_record_set" "all_apis" {
  managed_zone = google_dns_managed_zone.googleapis.name
  name         = "*.googleapis.com."
  type         = "CNAME"
  ttl          = 300
  rrdatas      = ["restricted.googleapis.com."]
}

# Outbound: HTTPS to the restricted range only. Everything else is refused
# and logged.
resource "google_compute_firewall" "allow_apis" {
  name               = "forensics-allow-restricted-apis"
  network            = google_compute_network.forensics.id
  direction          = "EGRESS"
  priority           = 1000
  destination_ranges = ["199.36.153.4/30"]
  allow {
    protocol = "tcp"
    ports    = ["443"]
  }
}

resource "google_compute_firewall" "deny_out" {
  name               = "forensics-deny-all-egress"
  network            = google_compute_network.forensics.id
  direction          = "EGRESS"
  priority           = 65000
  destination_ranges = ["0.0.0.0/0"]
  deny {
    protocol = "all"
  }
  log_config {
    metadata = "INCLUDE_ALL_METADATA"
  }
}

# Inbound: SSH from Identity-Aware Proxy's range, and nothing else.
resource "google_compute_firewall" "iap_ssh" {
  name          = "forensics-allow-iap-ssh"
  network       = google_compute_network.forensics.id
  direction     = "INGRESS"
  priority      = 1000
  source_ranges = ["35.235.240.0/20"]
  target_tags   = ["forensic-workstation"]
  allow {
    protocol = "tcp"
    ports    = ["22"]
  }
}

resource "google_service_account" "workstation" {
  account_id   = "forensic-workstation"
  display_name = "Forensic workstation: reads evidence, nothing else"
}

resource "google_storage_bucket_iam_member" "read_evidence" {
  bucket = local.evidence_bucket
  role   = "roles/storage.objectViewer"
  member = "serviceAccount:${google_service_account.workstation.email}"
}

resource "google_compute_instance" "workstation" {
  name         = "forensic-workstation"
  zone         = local.zone
  machine_type = "n2-highmem-4"
  tags         = ["forensic-workstation"]

  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
      size  = 200
      type  = "pd-balanced"
    }
  }

  # No access_config block, so no external address.
  network_interface {
    subnetwork = google_compute_subnetwork.forensics.id
  }

  service_account {
    email  = google_service_account.workstation.email
    scopes = ["cloud-platform"]
  }

  metadata = {
    enable-oslogin         = "TRUE"
    block-project-ssh-keys = "TRUE"
  }

  shielded_instance_config {
    enable_secure_boot          = true
    enable_vtpm                 = true
    enable_integrity_monitoring = true
  }

  # The image moves with every Debian release. Replace the workstation on
  # purpose, never because a plan noticed a new image.
  lifecycle {
    ignore_changes = [boot_disk[0].initialize_params[0].image]
  }
}

resource "google_iap_tunnel_instance_iam_member" "analyst" {
  instance = google_compute_instance.workstation.name
  zone     = local.zone
  role     = "roles/iap.tunnelResourceAccessor"
  member   = local.analyst
}

# Admin login on this workstation only, because mounting an evidence disk
# needs root. Nowhere else in the project gains it.
resource "google_compute_instance_iam_member" "analyst_login" {
  instance_name = google_compute_instance.workstation.name
  zone          = local.zone
  role          = "roles/compute.osAdminLogin"
  member        = local.analyst
}

output "attach_snapshot" {
  description = "Examine a disk snapshot here. Google Cloud can attach a disk read-only, so nothing on the workstation can change it."
  value       = <<-EOT
    gcloud compute disks create evidence-1 --source-snapshot <snapshot> --zone ${local.zone}
    gcloud compute instances attach-disk forensic-workstation --disk evidence-1 --mode ro --zone ${local.zone}
    Then, in the session: sudo mkdir -p /mnt/evidence && sudo mount -o ro,noload /dev/sdb1 /mnt/evidence
  EOT
}
