hash
A short fixed-length fingerprint calculated from data, which changes completely if even one byte of the data changes.
In more detail
A cryptographic hash function such as SHA-256 is designed so that you cannot find two different inputs with the same fingerprint, and cannot work backwards from the fingerprint to the data. That makes a hash a reliable name for content and a quick check that data was not corrupted or tampered with. The same input always gives the same hash.
Examples
Kafka partitioners hash the record key with murmur2 to choose a partition.The course build prints a checksum of the archive as its digest, so any later stage can check it holds exactly the bytes that were tested.In the browser: The same input always gives the same hash, but you cannot work backwards from the hash to the input. Hashes are used to check that data has not been changed and to name content by what it contains.createHash("sha256").update(input).digest("hex")printf 'Revenue is up.\n' | git hash-object --stdin prints the hash Git would use as that content's name.sha256sum healthcheck > healthcheck.sha256A cryptographic hash function such as SHA-256 is designed so you cannot find two inputs with the same result or work backwards to the input. Linux uses hashes to store passwords and to check downloaded packages against their signed repository index. A hash-based load balancer uses a non-cryptographic hash of the client address to keep choosing the same backend.Sysmon records SHA-256, MD5 and imphash values for each process image; imaging tools hash evidence while copying it.Flipping one bit of wheel.bin changes its SHA-256 digest completelyIn Terraform: The dependency lock file stores hashes of each provider package, and terraform init refuses a download whose hash does not match. Plans also show file checksums as known after apply, because a file that does not exist yet cannot be fingerprinted.Related terms
- HMAC — A way of combining a secret key with a hash function to produce a tag that shows a message came from someone holding the key and was not changed.
- SHA-256 — A widely used hash function that turns any data into a 256-bit fingerprint, shown as 64 hexadecimal characters.
- request fingerprint — A value, often a hash, calculated from the important parts of a request so the server can tell whether a repeated request is really the same one.
- hashFiles — A workflow expression function that returns one SHA-256 hash for the files matching a pattern.
- shasum — A command-line tool that prints the SHA checksum of files, with -a 256 selecting SHA-256.
- murmur2 — A fast, non-cryptographic hash function that Kafka clients use to turn a record key into a partition number.
- partitioner — The producer component that chooses which partition each record is sent to.
- digest — A SHA-256 hash of an image's manifest that identifies its exact content and can never be moved to other bytes.
- artifact — A file produced by a build, such as a compiled program or an image, that is stored and passed on to later steps.
- content addressing — Storing and finding data by a hash of its content instead of by a name someone chose.
- cache — A store of earlier answers kept close to where they are needed so they can be reused instead of fetched or computed again.
- salt — An extra value mixed into data before hashing so that otherwise identical inputs produce different hashes.
- SHA-1 — An older hash function producing a 160-bit value, now considered broken for security because collisions can be created on purpose.
- object ID — The hash that names a Git object, such as a commit, and that you type to refer to it.
- password hash — A one-way scrambled form of a password that lets a system check a login without storing the password itself.
- package signing — The use of cryptographic signatures on packages or repository metadata so a package manager can reject software that did not come from a trusted publisher.
- session affinity — Sending all requests from one client to the same backend, often by hashing the client address or using a cookie.
- error digest — A short generated hash attached to server errors so you can match what the user sees with the full error in the server logs.
- digital signature — A value computed from data and a secret key that lets anyone with the matching verification key confirm the data came from the key holder and was not changed.
- consistent hashing — A way of mapping keys to servers on a ring so that adding or removing a server moves only a small share of keys.
- hot key — A single key that receives a large share of all traffic, such as a celebrity account or a popular event.
- partition key — The DynamoDB attribute whose value decides which storage partition an item lives in, and which every query must name.
- dependency lock file — The .terraform.lock.hcl file that terraform init writes to record the exact provider versions chosen and their checksums.
Taught in
- Prompts As Code — AI Engineering: LLM Apps, RAG & Agents
- Chunking And Ingestion — AI Engineering: LLM Apps, RAG & Agents
- Remote Servers And Trust — AI Engineering: LLM Apps, RAG & Agents
- Idempotency Keys — Modern API Architecture: REST, GraphQL & gRPC
- JSON Web Tokens — Modern API Architecture: REST, GraphQL & gRPC
- Webhooks Versus Polling — Modern API Architecture: REST, GraphQL & gRPC
- Speeding Up Builds: Caching Dependencies — Continuous Integration & Continuous Delivery Pipelines
- Container Images The Exam Way — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Kustomize Bases, Overlays And Patches — Certified Kubernetes Application Developer (CKAD) Exam Prep
- Verify Binaries: A Hash With No Name — Certified Kubernetes Security Specialist (CKS) Exam Prep
- SBOMs: Knowing What You Ship — Certified Kubernetes Security Specialist (CKS) Exam Prep
- Signing And Verifying Images With Cosign — Certified Kubernetes Security Specialist (CKS) Exam Prep
- Shift-Left Security Principles & Automated Pipeline Gates — Cloud Security & DevSecOps Engineering
- Enforcing OPA Guardrails on Terraform Plan Payloads — Cloud Security & DevSecOps Engineering
- CloudTrail Logging, Integrity Validation & Athena — Cloud Security & DevSecOps Engineering
- The Queue That Forgot — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Where A Record Lands — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- The Error Storm That Fixes Itself — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Works On A Laptop, Fails In Production — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Forty Minutes To Count Again — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- Where Is The Password Kept? — Confluent Apache Kafka Certifications (CCDAK and CCAAK) Exam Prep
- CIA Triad, Non-Repudiation & Parkerian Hexad — Cybersecurity Fundamentals, GRC & Cryptography
- Security Baselines, Policies & Hardening Standards — Cybersecurity Fundamentals, GRC & Cryptography
- Regulatory Compliance: SOC 2, HIPAA, GDPR & PCI-DSS — Cybersecurity Fundamentals, GRC & Cryptography
- Symmetric Encryption: AES-GCM & ChaCha20 — Cybersecurity Fundamentals, GRC & Cryptography
- Cryptographic Hashing: SHA-256, SHA-3 & Passwords — Cybersecurity Fundamentals, GRC & Cryptography
- Post-Quantum Cryptography & Key Lifecycles — Cybersecurity Fundamentals, GRC & Cryptography
- Data States: Security at Rest, in Transit, and in Use — Cybersecurity Fundamentals, GRC & Cryptography
- Data Loss Prevention & Egress Monitoring — Cybersecurity Fundamentals, GRC & Cryptography
- Backup Architectures: 3-2-1, Immutability & Air-Gaps — Cybersecurity Fundamentals, GRC & Cryptography
- Internal Audits, Sampling & Evidence Chains — Cybersecurity Fundamentals, GRC & Cryptography
- Security Capstone Review & Certification — Cybersecurity Fundamentals, GRC & Cryptography
- Building And Versioning The Artifact — DevOps & Site Reliability Engineering
- Pull And Inspect A Third Party Image — Docker Architecture & Production Containers
- Build Context, Dockerignore And Your First Dockerfile — Docker Architecture & Production Containers
- FROM, WORKDIR, COPY And ADD — Docker Architecture & Production Containers
- RUN, SHELL And Efficient Layer Caching — Docker Architecture & Production Containers
- Tags, Digests And Reproducible Image References — Docker Architecture & Production Containers
- Authenticate, Tag, Push And Pull From A Registry — Docker Architecture & Production Containers
- Build, Test And Promote The Same Image In CI — Docker Architecture & Production Containers
- From Local Containers To Kubernetes — Docker Architecture & Production Containers
- CSRF Mitigations, SameSite Cookies And Subresource Integrity — Frontend Architecture & Web Platform
- Monorepo Architecture: Workspaces & Turborepo — Production Full-Stack Engineering
- Unified Build Pipelines: Caching & Dependency Graphs — Production Full-Stack Engineering
- OAuth2 & OpenID Connect: Social Auth & PKCE Flows — Production Full-Stack Engineering
- Why Version Control, And Why Git Won — Advanced Git Internals & Distributed Workflows
- What A Commit Really Is — Advanced Git Internals & Distributed Workflows
- Committing, And What A Good Message Says — Advanced Git Internals & Distributed Workflows
- Rebase: The Same Work, A Different History — Advanced Git Internals & Distributed Workflows
- Amend, And The One Hard Rule — Advanced Git Internals & Distributed Workflows
- Cherry Picking, Reflog, And Getting Work Back — Advanced Git Internals & Distributed Workflows
- Investigating History: blame, bisect And worktree — Advanced Git Internals & Distributed Workflows
- Tags And Releases — Advanced Git Internals & Distributed Workflows
- Building Static Binaries — Concurrent Systems Programming with Go
- Topics, Partitions And Where A Record Lands — Apache Kafka & Event Streaming
- Keys And Ordering Per Partition — Apache Kafka & Event Streaming
- ConfigMaps, Secrets And Configuration Updates — Kubernetes: Production-Grade Container Orchestration
- StatefulSets, Stable Identity And Data Recovery — Kubernetes: Production-Grade Container Orchestration
- Troubleshooting: OOMKilled, Throttling And Evictions — Kubernetes: Production-Grade Container Orchestration
- etcd Snapshots And A Tested Restore — Kubernetes: Production-Grade Container Orchestration
- Users, UIDs And The Password File — Linux Fundamentals & Systems Administration
- What A Package Manager Guarantees — Linux Fundamentals & Systems Administration
- Load Balancing: Algorithms, Health Checks And Layers — Linux Fundamentals & Systems Administration
- Error Boundaries: Nested error.tsx & Reset Logic — Next.js 15 & Modern App Router Architecture
- Session Management: Secure Cookies & Token Validation — Next.js 15 & Modern App Router Architecture
- libuv Architecture: Event Demultiplexer & Thread Pool — Node.js Internals & Backend Services
- Cryptographic Primitives: node:crypto & Ciphers — Node.js Internals & Backend Services
- Native HTTP Server: Request & Response Lifecycles — Node.js Internals & Backend Services
- SIEM Architecture: Ingestion Pipelines & Indexing — Security Operations & Threat Hunting (SOC)
- Windows Event Logs, Sysmon & Linux Auditd Telemetry — Security Operations & Threat Hunting (SOC)
- YARA Rule Authoring & File Signature Matching — Security Operations & Threat Hunting (SOC)
- Adversary Tactics, Techniques & Procedures (TTP) Mapping — Security Operations & Threat Hunting (SOC)
- Indicator of Compromise Extraction & Threat Hunting Feeds — Security Operations & Threat Hunting (SOC)
- Recovery & System Validation Testing — Security Operations & Threat Hunting (SOC)
- Forensics Principles, Custody & Imaging — Security Operations & Threat Hunting (SOC)
- Disk Forensics: MFT, UsnJrnl & Prefetch — Security Operations & Threat Hunting (SOC)
- Memory Forensics: Process Trees & Injection — Security Operations & Threat Hunting (SOC)
- Malware Triage: Hashes, Strings & Sandboxing — Security Operations & Threat Hunting (SOC)
- Workload Identity — Application Security & Threat Modeling for Engineers
- TLS And The Handshake — Application Security & Threat Modeling for Engineers
- Lockfiles And Reproducible Builds — Application Security & Threat Modeling for Engineers
- Provenance And Signing — Application Security & Threat Modeling for Engineers
- Secret Scanning — Application Security & Threat Modeling for Engineers
- The Storage Decision: Key Value, Search And Blob — Scalable System Design & Distributed Architecture
- Partitioning, Sharding And Hot Keys — Scalable System Design & Distributed Architecture
- Load Balancing And The Failure Modes It Introduces — Scalable System Design & Distributed Architecture
- Worked Design One: Scaling The Ticket Booking System — Scalable System Design & Distributed Architecture
- Worked Design Three: Scaling The Metrics Pipeline — Scalable System Design & Distributed Architecture
- Providers And The required_providers Block — Infrastructure as Code with Terraform
- Predicting Changes, Then Applying Them — Infrastructure as Code with Terraform
- Providers: How Terraform Reaches Every API — HashiCorp Terraform Associate (004) Exam Prep
- Versions, The Lock File And Provider Aliases — HashiCorp Terraform Associate (004) Exam Prep
- State: Terraform's Memory Of What It Built — HashiCorp Terraform Associate (004) Exam Prep
- Resources, Data Sources And The References Between Them — HashiCorp Terraform Associate (004) Exam Prep
- Module Versions: Pin, Upgrade, Re-Initialise — HashiCorp Terraform Associate (004) Exam Prep
- The Full Mock: Sixty Minutes, Eight Areas, One Plan For The Last Week — HashiCorp Terraform Associate (004) Exam Prep
- A Card With No Driver, A Stick With Too Much: Devices And Kernel Modules — CompTIA Linux+ (XK0-006) Exam Prep
- Friday's Backup, Monday's Restore: Incrementals, Images And Compressed Logs — CompTIA Linux+ (XK0-006) Exam Prep
- Starters, Leavers And A Service Account: Accounts On Two Families — CompTIA Linux+ (XK0-006) Exam Prep
- Three Audit Findings And A Phone: Password Policy, Lockouts And MFA — CompTIA Linux+ (XK0-006) Exam Prep
- The Certificate That Expired On A Sunday: Hashes, Encryption And Certificates — CompTIA Linux+ (XK0-006) Exam Prep
- What Changed Last Night? Integrity, Scans, Benchmarks And Secure Deletion — CompTIA Linux+ (XK0-006) Exam Prep
- The Cleanup That Emptied The Wrong Directory: Shell Scripts Under Exam Conditions — CompTIA Linux+ (XK0-006) Exam Prep
- Ninety Minutes, Five Domains: The Full Mock And The Week Before The Exam — CompTIA Linux+ (XK0-006) Exam Prep
References
- NIST glossary: hash function
- NIST: Hash functions
- FIPS 180-4 Secure Hash Standard
- MDN Glossary: Hash function
- Node.js: crypto.createHash
- Git reference: git hash-object
- MDN glossary: HMAC
- Python docs: hashlib
- Dependency lock file: checksum verification
Certification courses
- AWS AIP-C01 course and practice exam: AI engineering with LLM apps, RAG and agents
- CKAD course and practice exam: Certified Kubernetes Application Developer
- CKS course and practice exam: Certified Kubernetes Security Specialist
- CCDAK and CCAAK course and practice exams: Confluent Apache Kafka certifications
- Terraform Associate course and practice exam: HashiCorp Terraform Associate (004)
- CompTIA Linux+ course and practice exam: XK0-006