{"id":57985,"date":"2026-10-29T11:42:14","date_gmt":"2026-10-29T03:42:14","guid":{"rendered":"https:\/\/www.amagicsoft.com\/?p=57985"},"modified":"2026-10-29T11:42:14","modified_gmt":"2026-10-29T03:42:14","slug":"gpt-partition-entry","status":"publish","type":"post","link":"https:\/\/www.amagicsoft.com\/fr\/kb\/disk-partition\/gpt-partition-entry.html","title":{"rendered":"Entr\u00e9e de partition GPT : champs \u00ab Structure \u00bb, \u00ab Array \u00bb et \u00ab GUID \u00bb"},"content":{"rendered":"\t\t<div data-elementor-type=\"wp-post\" data-elementor-id=\"57985\" class=\"elementor elementor-57985\" data-elementor-post-type=\"post\">\n\t\t\t\t<div class=\"elementor-element elementor-element-d2sp5m2 dtec-docx-root dtec-post-57985 e-flex e-con-boxed e-con e-parent\" data-id=\"d2sp5m2\" data-element_type=\"container\" data-e-type=\"container\">\n\t\t\t\t\t<div class=\"e-con-inner\">\n\t\t\t\t<div class=\"elementor-element elementor-element-vpfkdn5 elementor-widget elementor-widget-text-editor\" data-id=\"vpfkdn5\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<div><div><p class=\"otl-paragraph\">A <strong>GPT partition entry<\/strong> is a record that describes one partition on a GUID Partition Table (GPT) disk. It identifies the partition&#8217;s type, unique GUID, starting and ending logical block addresses (LBAs), attributes, and name. The usual <strong>GPT partition entry structure<\/strong> occupies 128 bytes. By decoding these fields, you can locate a partition, calculate its size, and check whether its metadata makes sense.<\/p><p class=\"otl-paragraph\">This guide follows UEFI Specification 2.10 and uses Windows 10, Windows 11, and Windows Server as practical examples. The underlying GPT format also applies to other compatible operating systems. Every byte example below is synthetic, not a capture from a real disk.<\/p><\/div><\/div>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-cd4pqzp elementor-toc--minimized-on-tablet elementor-widget elementor-widget-table-of-contents\" data-id=\"cd4pqzp\" data-element_type=\"widget\" data-e-type=\"widget\" data-settings=\"{&quot;headings_by_tags&quot;:[&quot;h2&quot;,&quot;h3&quot;],&quot;exclude_headings_by_selector&quot;:&quot;.faq-no-toc, h2:contains(Data Recovery Assessment)&quot;,&quot;marker_view&quot;:&quot;bullets&quot;,&quot;no_headings_message&quot;:&quot;No headings were found on this page.&quot;,&quot;icon&quot;:{&quot;value&quot;:&quot;fas fa-circle&quot;,&quot;library&quot;:&quot;fa-solid&quot;},&quot;minimize_box&quot;:&quot;yes&quot;,&quot;minimized_on&quot;:&quot;tablet&quot;,&quot;hierarchical_view&quot;:&quot;yes&quot;,&quot;min_height&quot;:{&quot;unit&quot;:&quot;px&quot;,&quot;size&quot;:&quot;&quot;,&quot;sizes&quot;:[]},&quot;min_height_tablet&quot;:{&quot;unit&quot;:&quot;px&quot;,&quot;size&quot;:&quot;&quot;,&quot;sizes&quot;:[]},&quot;min_height_mobile&quot;:{&quot;unit&quot;:&quot;px&quot;,&quot;size&quot;:&quot;&quot;,&quot;sizes&quot;:[]}}\" data-widget_type=\"table-of-contents.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<div class=\"elementor-toc__header\">\n\t\t\t\t\t\t<h4 class=\"elementor-toc__header-title\">\n\t\t\t\tTable of Contents\t\t\t<\/h4>\n\t\t\t\t\t\t\t\t\t\t<div class=\"elementor-toc__toggle-button elementor-toc__toggle-button--expand\" role=\"button\" tabindex=\"0\" aria-controls=\"elementor-toc__cd4pqzp\" aria-expanded=\"true\" aria-label=\"Abrir Tabela de Conte\u00fados\"><i aria-hidden=\"true\" class=\"fas fa-chevron-down\"><\/i><\/div>\n\t\t\t\t<div class=\"elementor-toc__toggle-button elementor-toc__toggle-button--collapse\" role=\"button\" tabindex=\"0\" aria-controls=\"elementor-toc__cd4pqzp\" aria-expanded=\"true\" aria-label=\"Fechar Tabela de Conte\u00fados\"><i aria-hidden=\"true\" class=\"fas fa-chevron-up\"><\/i><\/div>\n\t\t\t\t\t<\/div>\n\t\t\t\t<div id=\"elementor-toc__cd4pqzp\" class=\"elementor-toc__body\">\n\t\t\t<div class=\"elementor-toc__spinner-container\">\n\t\t\t\t<i class=\"elementor-toc__spinner eicon-animation-spin eicon-loading\" aria-hidden=\"true\"><\/i>\t\t\t<\/div>\n\t\t<\/div>\n\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-lnpvz6b elementor-widget elementor-widget-heading\" data-id=\"lnpvz6b\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">What Is a GPT Partition Entry?<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-zg2hiuq elementor-widget elementor-widget-text-editor\" data-id=\"zg2hiuq\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>A <strong>GPT partition entry<\/strong> defines a partition&#8217;s identity and boundaries; it does not contain the partition&#8217;s files. To see where it fits, separate three structures:<\/p>\n<table><tbody><tr><td><p><strong>Structure<\/strong><\/p><\/td><td><p><strong>What it stores<\/strong><\/p><\/td><\/tr><tr><td><p>GPT Header<\/p><\/td><td><p>Array location, entry count and size, usable LBA range, and checksums<\/p><\/td><\/tr><tr><td><p><strong>GPT Partition Entry Array<\/strong><\/p><\/td><td><p>A sequence of partition records, including unused slots<\/p><\/td><\/tr><tr><td><p><strong>GPT partition entry<\/strong><\/p><\/td><td><p>One partition&#8217;s GUIDs, boundaries, attributes, and name<\/p><\/td><\/tr><\/tbody><\/table>\n<p>The entry directs the operating system to a region of logical blocks. That region may hold NTFS, FAT32, exFAT, another file system, or data without a conventional file system.<\/p>\n<p>For the overall disk layout, see Amagicsoft&#8217;s <a href=\"https:\/\/www.amagicsoft.com\/wiki\/learn-what-gpt-is.html\">GUID Partition Table (GPT) overview<\/a>.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-a7dio90 elementor-widget elementor-widget-heading\" data-id=\"a7dio90\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">GPT Partition Entry Structure: Six Fields and Their Offsets<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-idx4ogn elementor-widget elementor-widget-text-editor\" data-id=\"idx4ogn\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p><a href=\"https:\/\/uefi.org\/specs\/UEFI\/2.10\/05_GUID_Partition_Table_Format.html\" rel=\"nofollow\">UEFI Specification 2.10, Section 5.3.3<\/a> defines the standard 128-byte <strong>GPT partition entry structure<\/strong>:<\/p><table><tbody><tr><td><p><strong>Field<\/strong><\/p><\/td><td><p><strong>Relative offset<\/strong><\/p><\/td><td><p><strong>Length<\/strong><\/p><\/td><td><p><strong>Meaning<\/strong><\/p><\/td><\/tr><tr><td><p><code class=\"dtec-inline-code\">PartitionTypeGUID<\/code><\/p><\/td><td><p><code class=\"dtec-inline-code\">0x00\u20130x0F<\/code><\/p><\/td><td><p>16 bytes<\/p><\/td><td><p>Intended partition type<\/p><\/td><\/tr><tr><td><p><code class=\"dtec-inline-code\">UniquePartitionGUID<\/code><\/p><\/td><td><p><code class=\"dtec-inline-code\">0x10\u20130x1F<\/code><\/p><\/td><td><p>16 bytes<\/p><\/td><td><p>Identifier for this specific partition<\/p><\/td><\/tr><tr><td><p><code class=\"dtec-inline-code\">StartingLBA<\/code><\/p><\/td><td><p><code class=\"dtec-inline-code\">0x20\u20130x27<\/code><\/p><\/td><td><p>8 bytes<\/p><\/td><td><p>First logical block<\/p><\/td><\/tr><tr><td><p><code class=\"dtec-inline-code\">EndingLBA<\/code><\/p><\/td><td><p><code class=\"dtec-inline-code\">0x28\u20130x2F<\/code><\/p><\/td><td><p>8 bytes<\/p><\/td><td><p>Last logical block, inclusive<\/p><\/td><\/tr><tr><td><p><code class=\"dtec-inline-code\">Attributes<\/code><\/p><\/td><td><p><code class=\"dtec-inline-code\">0x30\u20130x37<\/code><\/p><\/td><td><p>8 bytes<\/p><\/td><td><p>64-bit attribute mask<\/p><\/td><\/tr><tr><td><p><code class=\"dtec-inline-code\">PartitionName<\/code><\/p><\/td><td><p><code class=\"dtec-inline-code\">0x38\u20130x7F<\/code><\/p><\/td><td><p>72 bytes<\/p><\/td><td><p>Name stored as UTF-16LE code units<\/p><\/td><\/tr><\/tbody><\/table><p>These offsets start at the beginning of <em>one entry<\/em>, not at the beginning of the disk. Also, 128 bytes is the common entry size, not the only legal one. Under UEFI 2.10, <code class=\"dtec-inline-code\">SizeOfPartitionEntry<\/code> must equal <code class=\"dtec-inline-code\">128 \u00d7 2^n<\/code>, with nonnegative integer <code class=\"dtec-inline-code\">n<\/code>. For larger entries, bytes beyond offset <code class=\"dtec-inline-code\">0x7F<\/code> are reserved and must be zero.<\/p><h3>The two GUID fields<\/h3><p><code class=\"dtec-inline-code\">PartitionTypeGUID<\/code> tells software what kind of partition an entry describes. <code class=\"dtec-inline-code\">UniquePartitionGUID<\/code> identifies the particular partition. For example, two Basic Data partitions may share a type GUID but should not share a unique partition GUID.<\/p><p>Neither field is the GPT disk identifier. The <code class=\"dtec-inline-code\">DiskGUID<\/code> belongs to the GPT Header.<\/p><h3>LBA boundaries and partition size<\/h3><p>A <strong>GPT partition entry<\/strong> stores both endpoints as unsigned, little-endian 64-bit integers. Because <code class=\"dtec-inline-code\">EndingLBA<\/code> is inclusive, calculate the block count and capacity as follows:<\/p><p><strong>Block count = <\/strong><code class=\"dtec-inline-code\"><strong>EndingLBA \u2212 StartingLBA + 1<\/strong><\/code><\/p><p><strong>Size in bytes = Block count \u00d7 Logical block size<\/strong><\/p><p>If a partition runs from LBA 2048 through LBA 4095, it spans 2,048 blocks. With 512-byte logical blocks, its size is 1 MiB. With 4096-byte logical blocks, its size is 8 MiB. Never assume that an LBA always represents 512 bytes.<\/p><h3>Attributes and partition name<\/h3><p>The <code class=\"dtec-inline-code\">Attributes<\/code> field holds a 64-bit mask. UEFI defines bit 0 as Required Partition, bit 1 as No Block I\/O Protocol, and bit 2 as Legacy BIOS Bootable. Under UEFI 2.10, bits 3\u201347 are reserved, while bits 48\u201363 are partition-type-specific.<\/p><p>For applicable Windows partition types, <a href=\"https:\/\/learn.microsoft.com\/en-us\/windows\/win32\/api\/winioctl\/ns-winioctl-partition_information_gpt\" rel=\"nofollow\">Microsoft&#8217;s GPT partition information documentation<\/a> defines high-bit flags, including read-only (bit 60), shadow copy (61), hidden (62), and no default drive letter (63). Do not apply those Windows meanings indiscriminately to every partition type.<\/p><p><code class=\"dtec-inline-code\">PartitionName<\/code> contains 36 UTF-16 code units (72 bytes). A shorter name uses null termination. Importantly, this GPT name is distinct from the volume label stored within a file system. Reading a <strong>GPT partition entry<\/strong> alone does not establish the label that Windows displays for a mounted volume.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-ngx1f1j elementor-widget elementor-widget-heading\" data-id=\"ngx1f1j\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">How the GPT Partition Entry Array Works<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-wd8oml1 elementor-widget elementor-widget-text-editor\" data-id=\"wd8oml1\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>The <strong>GPT partition entry array<\/strong> holds consecutive slots of equal size. Its GPT Header specifies <code class=\"dtec-inline-code\">PartitionEntryLBA<\/code>, <code class=\"dtec-inline-code\">NumberOfPartitionEntries<\/code>, and <code class=\"dtec-inline-code\">SizeOfPartitionEntry<\/code>. Therefore, software reads the Header before it can reliably locate a particular record.<\/p>\n<p><strong>Array bytes = NumberOfPartitionEntries \u00d7 SizeOfPartitionEntry<\/strong><\/p>\n<p><strong>Array logical blocks = ceiling(Array bytes \u00f7 Logical block size)<\/strong><\/p>\n<p>UEFI 2.10 requires at least 16,384 bytes of space for the Entry Array. A common configuration uses 128 slots of 128 bytes each. Consequently, it occupies 32 blocks on a 512-byte logical-block disk, or four blocks on a 4096-byte disk. However, 128 is not a universal partition limit. The Header specifies the entry count.<\/p>\n<p>An unused slot has a zero <code class=\"dtec-inline-code\">PartitionTypeGUID<\/code>; its other bytes should also be zero in a properly maintained array. So 128 available slots do <strong>not<\/strong> mean 128 active partitions.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-mfwuaa1 elementor-widget elementor-widget-image\" data-id=\"mfwuaa1\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"image.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<img decoding=\"async\" src=\"https:\/\/www.amagicsoft.com\/wp-content\/uploads\/2026\/10\/gpt_entry_array_partition_boundaries.webp\" title=\"\" alt=\"GPT partition entry array showing active entries, unused slots, and their corresponding non-overlapping LBA ranges\" loading=\"lazy\" \/>\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-cwq0fz4 elementor-widget elementor-widget-text-editor\" data-id=\"cwq0fz4\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<h3>Find a specific entry by index<\/h3>\n<p>To find entry <em>i<\/em>, where <em>i<\/em> begins at zero, use:<\/p>\n<p><strong>Absolute byte offset = (<\/strong><code class=\"dtec-inline-code\"><strong>PartitionEntryLBA<\/strong><\/code><strong> \u00d7 Logical block size) + (i \u00d7 <\/strong><code class=\"dtec-inline-code\"><strong>SizeOfPartitionEntry<\/strong><\/code><strong>)<\/strong><\/p>\n<p>For example, suppose <code class=\"dtec-inline-code\">PartitionEntryLBA = 2<\/code>, <code class=\"dtec-inline-code\">SizeOfPartitionEntry = 128<\/code>, and <code class=\"dtec-inline-code\">i = 5<\/code>.<\/p>\n<table><tbody><tr><td><p><strong>Logical block size<\/strong><\/p><\/td><td><p><strong>Calculated absolute offset<\/strong><\/p><\/td><td><p><strong>Position on disk<\/strong><\/p><\/td><\/tr><tr><td><p>512 bytes<\/p><\/td><td><p><code class=\"dtec-inline-code\">(2 \u00d7 512) + (5 \u00d7 128) = 1664<\/code><\/p><\/td><td><p>LBA 3, byte 128<\/p><\/td><\/tr><tr><td><p>4096 bytes<\/p><\/td><td><p><code class=\"dtec-inline-code\">(2 \u00d7 4096) + (5 \u00d7 128) = 8832<\/code><\/p><\/td><td><p>LBA 2, byte 640<\/p><\/td><\/tr><\/tbody><\/table>\n<p>These are calculations for a declared example, not observations of two physical devices. Notice that the same <strong>GPT partition entry<\/strong> index can fall in different LBAs when the device&#8217;s logical block size changes.<\/p>\n<h3>Primary and backup arrays<\/h3>\n<p>A conventional GPT disk places its primary Header at LBA 1 and its backup Header at the final LBA. The primary Entry Array normally follows the primary Header; the backup array sits before the backup Header. Their locations come from the respective Header fields, not a universal hard-coded sector range.<\/p>\n<p>Our <a href=\"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-header.html\">GPT Header structure and CRC32 guide<\/a> explains these Header fields and the relationship between the two arrays in detail.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-301lfq8 elementor-widget elementor-widget-heading\" data-id=\"301lfq8\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">GPT Partition Type GUID vs. Unique Partition GUID<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-fznc4zm elementor-widget elementor-widget-text-editor\" data-id=\"fznc4zm\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>A <strong>GPT partition type GUID<\/strong> describes the intended use of the partition. A Unique Partition GUID identifies a particular partition, while the Disk GUID identifies the GPT disk. These three identifiers are related but are not interchangeable.<\/p>\n<p>Common Windows-related type GUIDs include:<\/p>\n<table><tbody><tr><td><p><strong>Partition type<\/strong><\/p><\/td><td><p><strong>Type GUID<\/strong><\/p><\/td><\/tr><tr><td><p>EFI System Partition<\/p><\/td><td><p><code class=\"dtec-inline-code\">C12A7328-F81F-11D2-BA4B-00A0C93EC93B<\/code><\/p><\/td><\/tr><tr><td><p>Microsoft Reserved<\/p><\/td><td><p><code class=\"dtec-inline-code\">E3C9E316-0B5C-4DB8-817D-F92DF00215AE<\/code><\/p><\/td><\/tr><tr><td><p>Microsoft Basic Data<\/p><\/td><td><p><code class=\"dtec-inline-code\">EBD0A0A2-B9E5-4433-87C0-68B6B72699C7<\/code><\/p><\/td><\/tr><tr><td><p>Microsoft Recovery<\/p><\/td><td><p><code class=\"dtec-inline-code\">DE94BBA4-06D1-4D40-A16A-BFD50179D6AC<\/code><\/p><\/td><\/tr><\/tbody><\/table>\n<p>A type GUID does <strong>not<\/strong> directly identify a file system. For example, a Microsoft Basic Data partition could hold NTFS, FAT32, or exFAT. To recognize its file system, software must inspect data inside the partition.<\/p>\n<p>Likewise, not every GPT disk has an EFI System Partition. An ordinary GPT data disk may not need one.<\/p>\n<p>When copying disks, duplicate unique identifiers can also matter. UEFI requires GPT-aware copying software to generate appropriate new Disk GUIDs and Unique Partition GUIDs. A raw clone may preserve identifiers instead, so never assume that an exact copy has newly generated GUIDs.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-oegtqn3 elementor-widget elementor-widget-heading\" data-id=\"oegtqn3\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">Decode a GPT Partition Entry from Hex<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-cic8qld elementor-widget elementor-widget-text-editor\" data-id=\"cic8qld\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>Here is the article&#8217;s worked technical example: a synthetic <strong>GPT partition entry<\/strong> built from the UEFI field layout. It is internally consistent as a single entry, but it is not a complete GPT disk image or a real-world experiment.<\/p>\n<table><tbody><tr><td><p><strong>Field<\/strong><\/p><\/td><td><p><strong>Decoded example<\/strong><\/p><\/td><\/tr><tr><td><p>Type<\/p><\/td><td><p>Microsoft Basic Data<\/p><\/td><\/tr><tr><td><p>Type GUID<\/p><\/td><td><p><code class=\"dtec-inline-code\">EBD0A0A2-B9E5-4433-87C0-68B6B72699C7<\/code><\/p><\/td><\/tr><tr><td><p>Unique GUID<\/p><\/td><td><p><code class=\"dtec-inline-code\">01234567-89AB-4CDE-8123-001122334455<\/code><\/p><\/td><\/tr><tr><td><p>Starting LBA<\/p><\/td><td><p>2048<\/p><\/td><\/tr><tr><td><p>Ending LBA<\/p><\/td><td><p>4095<\/p><\/td><\/tr><tr><td><p>Attributes<\/p><\/td><td><p><code class=\"dtec-inline-code\">0x0000000000000000<\/code><\/p><\/td><\/tr><tr><td><p>Partition Name<\/p><\/td><td><p><code class=\"dtec-inline-code\">DATA<\/code><\/p><\/td><\/tr><\/tbody><\/table>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-ab8597a elementor-widget elementor-widget-html\" data-id=\"ab8597a\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"html.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<!-- Elementor HTML widget: self-contained, read-only teaching simulation. -->\r\n<div id=\"amg-gpt-entry-explorer-v1\" class=\"agpe\" aria-label=\"GPT partition entry hex field explorer\">\r\n  <div class=\"agpe-top\">\r\n    <div><div class=\"agpe-kicker\">ON-DISK STRUCTURE \u00b7 EDUCATIONAL SAMPLE<\/div><div class=\"agpe-title\">GPT Partition Entry \u00b7 128 bytes<\/div><\/div>\r\n    <div class=\"agpe-pill\">Read-only illustration<\/div>\r\n  <\/div>\r\n  <div class=\"agpe-guide\">Select a field or click any byte to see its on-disk value and decoded meaning.<\/div>\r\n  <div class=\"agpe-tabs\" role=\"group\" aria-label=\"GPT partition entry fields\"><\/div>\r\n  <div class=\"agpe-hex-shell\" role=\"region\" aria-label=\"Sixteen-byte hex rows with offsets and ASCII preview\" tabindex=\"0\">\r\n    <div class=\"agpe-hex-header\"><span>OFFSET<\/span><span>HEX BYTES (00\u20130F PER ROW)<\/span><span>ASCII<\/span><\/div>\r\n    <div class=\"agpe-hex\"><\/div>\r\n  <\/div>\r\n  <div class=\"agpe-output\" aria-live=\"polite\">\r\n    <div class=\"agpe-output-head\"><div class=\"agpe-output-label\">SELECTED FIELD<\/div><div class=\"agpe-range\"><\/div><\/div>\r\n    <div class=\"agpe-field-name\"><\/div>\r\n    <div class=\"agpe-raw-label\">Raw bytes (on disk)<\/div>\r\n    <div class=\"agpe-raw\"><\/div>\r\n    <div class=\"agpe-raw-label\">Decoded value<\/div>\r\n    <div class=\"agpe-decoded\"><\/div>\r\n    <p class=\"agpe-explainer\"><\/p>\r\n  <\/div>\r\n  <div class=\"agpe-calc\">\r\n    <div class=\"agpe-calc-left\"><strong>LBA size comparison<\/strong><span>The same 2048\u20134095 LBA range spans different byte capacities.<\/span><\/div>\r\n    <fieldset class=\"agpe-toggle\"><legend>Logical block size<\/legend><label><input type=\"radio\" name=\"agpe-v1-block\" value=\"512\" checked> 512 B<\/label><label><input type=\"radio\" name=\"agpe-v1-block\" value=\"4096\"> 4096 B<\/label><\/fieldset>\r\n    <div class=\"agpe-calc-values\"><div><small>Partition size<\/small><strong class=\"agpe-size\">1 MiB<\/strong><\/div><div><small>Start byte offset<\/small><strong class=\"agpe-start\">1,048,576<\/strong><\/div><\/div>\r\n  <\/div>\r\n  <p class=\"agpe-note\">Synthetic Basic Data partition entry, not a WinHex capture or a reading from your device. The entry is internally consistent; no complete disk layout or GPT header CRC is asserted.<\/p>\r\n<\/div>\r\n<style>\r\n#amg-gpt-entry-explorer-v1{box-sizing:border-box;--agpe-bg:#f6f8fa;--agpe-ink:#223245;--agpe-muted:#607084;--agpe-line:#dbe2ea;--agpe-blue:#0c5c97;--agpe-light:#d8edfd;background:#fff;border:1px solid var(--agpe-line);border-radius:12px;padding:18px;max-width:100%;color:var(--agpe-ink);font:14px\/1.5 system-ui,-apple-system,\"Segoe UI\",sans-serif}\r\n#amg-gpt-entry-explorer-v1 *{box-sizing:border-box}\r\n#amg-gpt-entry-explorer-v1 .agpe-top{display:flex;justify-content:space-between;gap:10px;align-items:center;flex-wrap:wrap}\r\n#amg-gpt-entry-explorer-v1 .agpe-kicker{font-size:10px;letter-spacing:1.05px;font-weight:800;color:var(--agpe-muted)}\r\n#amg-gpt-entry-explorer-v1 .agpe-title{font-size:19px;line-height:1.4;font-weight:750}\r\n#amg-gpt-entry-explorer-v1 .agpe-pill{border-radius:30px;background:#edf5ed;color:#316040;font-size:11px;padding:5px 9px;font-weight:650}\r\n#amg-gpt-entry-explorer-v1 .agpe-guide{color:var(--agpe-muted);margin:7px 0 12px;font-size:13px}\r\n#amg-gpt-entry-explorer-v1 .agpe-tabs{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:6px;margin:0 0 12px}\r\n#amg-gpt-entry-explorer-v1 .agpe-tab{border:1px solid var(--agpe-line);border-radius:6px;background:#fff;color:var(--agpe-ink);padding:9px 6px;min-height:44px;text-align:center;font:600 12px\/1.25 system-ui,-apple-system,\"Segoe UI\",sans-serif;cursor:pointer}\r\n#amg-gpt-entry-explorer-v1 .agpe-tab[aria-pressed=\"true\"]{border-color:var(--agpe-blue);background:var(--agpe-light);color:#124f7c}\r\n#amg-gpt-entry-explorer-v1 .agpe-tab:focus-visible,#amg-gpt-entry-explorer-v1 .agpe-byte:focus-visible{outline:3px solid #e49c39;outline-offset:2px}\r\n#amg-gpt-entry-explorer-v1 .agpe-hex-shell{overflow-x:auto;border:1px solid var(--agpe-line);background:#131f2e;border-radius:8px;padding:10px;color:#d9e3eb}\r\n#amg-gpt-entry-explorer-v1 .agpe-hex-header{display:grid;grid-template-columns:57px 512px 144px;gap:12px;min-width:737px;font:600 10px\/1.6 ui-monospace,SFMono-Regular,Consolas,monospace;color:#91b0c9;border-bottom:1px solid #39506a;padding-bottom:5px;margin-bottom:8px}\r\n#amg-gpt-entry-explorer-v1 .agpe-hex-row{display:grid;grid-template-columns:57px 512px 144px;gap:12px;min-width:737px;margin:1px 0;align-items:center}\r\n#amg-gpt-entry-explorer-v1 .agpe-offset{font:12px\/25px ui-monospace,SFMono-Regular,Consolas,monospace;color:#82a6c4}\r\n#amg-gpt-entry-explorer-v1 .agpe-byte-row{display:grid;grid-template-columns:repeat(16,30px);column-gap:2px}\r\n#amg-gpt-entry-explorer-v1 .agpe-byte{border:0;background:none;color:#e2e8f0;border-radius:3px;min-width:30px;min-height:25px;padding:2px 0;text-align:center;font:12px\/20px ui-monospace,SFMono-Regular,Consolas,monospace;cursor:pointer}\r\n#amg-gpt-entry-explorer-v1 .agpe-byte[data-active=\"true\"]{background:#2d7fb9;color:#fff}\r\n#amg-gpt-entry-explorer-v1 .agpe-ascii{font:12px\/25px ui-monospace,SFMono-Regular,Consolas,monospace;white-space:nowrap;letter-spacing:1.1px}\r\n#amg-gpt-entry-explorer-v1 .agpe-ascii span[data-active=\"true\"]{background:#2d7fb9;color:#fff;border-radius:2px}\r\n#amg-gpt-entry-explorer-v1 .agpe-output{margin-top:12px;border:1px solid var(--agpe-line);border-radius:9px;background:var(--agpe-bg);padding:14px}\r\n#amg-gpt-entry-explorer-v1 .agpe-output-head{display:flex;justify-content:space-between;gap:12px;flex-wrap:wrap}\r\n#amg-gpt-entry-explorer-v1 .agpe-output-label,#amg-gpt-entry-explorer-v1 .agpe-raw-label{font-size:10px;letter-spacing:.45px;text-transform:uppercase;font-weight:800;color:var(--agpe-muted)}\r\n#amg-gpt-entry-explorer-v1 .agpe-range{font:11px\/1.5 ui-monospace,SFMono-Regular,Consolas,monospace;color:var(--agpe-muted)}\r\n#amg-gpt-entry-explorer-v1 .agpe-field-name{font-size:16px;font-weight:750;margin:3px 0 8px}\r\n#amg-gpt-entry-explorer-v1 .agpe-raw{font:12px\/1.6 ui-monospace,SFMono-Regular,Consolas,monospace;overflow-wrap:anywhere;margin:3px 0 9px}\r\n#amg-gpt-entry-explorer-v1 .agpe-decoded{font:600 12px\/1.5 ui-monospace,SFMono-Regular,Consolas,monospace;color:#0c5c97;overflow-wrap:anywhere;margin:3px 0 4px}\r\n#amg-gpt-entry-explorer-v1 .agpe-explainer{font-size:12px;color:var(--agpe-muted);margin:6px 0 0}\r\n#amg-gpt-entry-explorer-v1 .agpe-calc{margin-top:12px;padding:12px;display:flex;gap:15px;align-items:center;justify-content:space-between;flex-wrap:wrap;border:1px solid var(--agpe-line);border-radius:9px}\r\n#amg-gpt-entry-explorer-v1 .agpe-calc-left{max-width:290px;display:grid;gap:2px}\r\n#amg-gpt-entry-explorer-v1 .agpe-calc-left strong{font-size:13px}\r\n#amg-gpt-entry-explorer-v1 .agpe-calc-left span{font-size:12px;color:var(--agpe-muted)}\r\n#amg-gpt-entry-explorer-v1 .agpe-toggle{display:flex;gap:13px;min-width:140px;border:0;padding:0;margin:0}\r\n#amg-gpt-entry-explorer-v1 .agpe-toggle legend{font-size:11px;color:var(--agpe-muted);margin-bottom:5px}\r\n#amg-gpt-entry-explorer-v1 .agpe-toggle label{font-size:12px;white-space:nowrap;cursor:pointer}\r\n#amg-gpt-entry-explorer-v1 .agpe-toggle input{accent-color:var(--agpe-blue)}\r\n#amg-gpt-entry-explorer-v1 .agpe-calc-values{display:flex;gap:15px;flex-wrap:wrap}\r\n#amg-gpt-entry-explorer-v1 .agpe-calc-values div{display:grid;gap:3px}\r\n#amg-gpt-entry-explorer-v1 .agpe-calc-values small{color:var(--agpe-muted);font-size:11px}\r\n#amg-gpt-entry-explorer-v1 .agpe-calc-values strong{font:700 14px ui-monospace,SFMono-Regular,Consolas,monospace}\r\n#amg-gpt-entry-explorer-v1 .agpe-note{font-size:11px;color:var(--agpe-muted);margin:12px 0 0}\r\n@media(max-width:640px){#amg-gpt-entry-explorer-v1{padding:12px}#amg-gpt-entry-explorer-v1 .agpe-tabs{grid-template-columns:repeat(2,minmax(0,1fr))}#amg-gpt-entry-explorer-v1 .agpe-hex-shell{padding:8px}#amg-gpt-entry-explorer-v1 .agpe-title{font-size:17px}}\r\n<\/style>\r\n<script>\r\n(function(){\r\n  'use strict';\r\n  const root = document.getElementById('amg-gpt-entry-explorer-v1');\r\n  if (!root || root.dataset.initialized === 'true') return;\r\n  root.dataset.initialized = 'true';\r\n  const bytes = new Uint8Array(128); \/\/ Entire entry is synthetic and zero-initialized.\r\n  bytes.set([0xA2,0xA0,0xD0,0xEB,0xE5,0xB9,0x33,0x44,0x87,0xC0,0x68,0xB6,0xB7,0x26,0x99,0xC7],0);\r\n  bytes.set([0x67,0x45,0x23,0x01,0xAB,0x89,0xDE,0x4C,0x81,0x23,0x00,0x11,0x22,0x33,0x44,0x55],16);\r\n  const view = new DataView(bytes.buffer);\r\n  view.setBigUint64(32,2048n,true);\r\n  view.setBigUint64(40,4095n,true);\r\n  view.setBigUint64(48,0n,true);\r\n  'DATA'.split('').forEach((character,i)=>view.setUint16(56+i*2,character.charCodeAt(0),true));\r\n  const fields = [\r\n    {name:'Partition Type GUID',offset:0,length:16,description:'Identifies the purpose of this partition. The sample is Microsoft Basic Data; it does not establish whether the file system is NTFS, exFAT, or another format.'},\r\n    {name:'Unique Partition GUID',offset:16,length:16,description:'Identifies this partition record, independently of the partition type and the disk GUID stored in the GPT header.'},\r\n    {name:'Starting LBA',offset:32,length:8,description:'Unsigned 64-bit little-endian number. The first logical block in the partition is 2048.'},\r\n    {name:'Ending LBA',offset:40,length:8,description:'Unsigned 64-bit little-endian number. The last logical block is included, so block count = end - start + 1.'},\r\n    {name:'Attributes',offset:48,length:8,description:'A 64-bit bitmask; zero means none of these attribute bits is set. Some high bits have type-specific meanings.'},\r\n    {name:'Partition Name',offset:56,length:72,description:'36 UTF-16 code units of partition-name storage, with a terminating NUL when the name is shorter. This is not the file-system volume label.'}\r\n  ];\r\n  const q = selector => root.querySelector(selector);\r\n  const hex = value => value.toString(16).toUpperCase().padStart(2,'0');\r\n  const hex4 = value => value.toString(16).toUpperCase().padStart(4,'0');\r\n  const fieldForByte = index => fields.findIndex(f => index >= f.offset && index < f.offset+f.length);\r\n  const formatGuid = start => {\r\n    const p = Array.from(bytes.slice(start,start+16),hex);\r\n    return [p.slice(0,4).reverse().join(''),p.slice(4,6).reverse().join(''),p.slice(6,8).reverse().join(''),p.slice(8,10).join(''),p.slice(10,16).join('')].join('-');\r\n  };\r\n  const formatNumber = number => number.toLocaleString('en-US');\r\n  let active = 0;\r\n  let blockSize = 512;\r\n  const tabs = q('.agpe-tabs');\r\n  fields.forEach((f,i)=>{\r\n    const button = document.createElement('button');\r\n    button.type='button';button.className='agpe-tab';button.textContent=f.name;\r\n    button.addEventListener('click',()=>select(i));\r\n    tabs.appendChild(button);\r\n  });\r\n  const rows = q('.agpe-hex');\r\n  const hexButtons = [];\r\n  const asciiSpans = [];\r\n  for(let row=0;row<8;row++){\r\n    const line=document.createElement('div');line.className='agpe-hex-row';\r\n    const offset=document.createElement('div');offset.className='agpe-offset';offset.textContent=hex4(row*16);\r\n    const byteRow=document.createElement('div');byteRow.className='agpe-byte-row';\r\n    const ascii=document.createElement('div');ascii.className='agpe-ascii';ascii.setAttribute('aria-hidden','true');\r\n    for(let col=0;col<16;col++){\r\n      const i=row*16+col;\r\n      const b=document.createElement('button');b.className='agpe-byte';b.type='button';\r\n      b.textContent=hex(bytes[i]);b.setAttribute('aria-label','Byte offset 0x'+hex4(i)+', value '+hex(bytes[i]));\r\n      b.addEventListener('click',()=>select(fieldForByte(i)));\r\n      byteRow.appendChild(b);hexButtons.push(b);\r\n      const char=document.createElement('span');char.textContent=bytes[i]>=32&&bytes[i]<127?String.fromCharCode(bytes[i]):'.';\r\n      ascii.appendChild(char);asciiSpans.push(char);\r\n    }\r\n    line.append(offset,byteRow,ascii);rows.appendChild(line);\r\n  }\r\n  function decoded(index){\r\n    if(index===0) return formatGuid(0)+' \u00b7 Microsoft Basic Data';\r\n    if(index===1) return formatGuid(16)+' \u00b7 Synthetic example identifier';\r\n    if(index===2) return formatNumber(view.getBigUint64(32,true))+' (0x'+view.getBigUint64(32,true).toString(16).toUpperCase()+')';\r\n    if(index===3) return formatNumber(view.getBigUint64(40,true))+' (0x'+view.getBigUint64(40,true).toString(16).toUpperCase()+')';\r\n    if(index===4) return '0x'+view.getBigUint64(48,true).toString(16).toUpperCase().padStart(16,'0')+' \u00b7 No attribute bits set';\r\n    let text='';for(let i=0;i<36;i++){let code=view.getUint16(56+2*i,true);if(code===0)break;text+=String.fromCharCode(code);}\r\n    return '\"'+text+'\" \u00b7 UTF-16LE';\r\n  }\r\n  function select(index){\r\n    if(index<0 || index>=fields.length)return;\r\n    active=index;const f=fields[active];\r\n    Array.from(tabs.children).forEach((b,i)=>b.setAttribute('aria-pressed',i===active?'true':'false'));\r\n    hexButtons.forEach((b,i)=>{const selected=fieldForByte(i)===active;b.dataset.active=selected?'true':'false';b.setAttribute('aria-pressed',selected?'true':'false');});\r\n    asciiSpans.forEach((span,i)=>span.dataset.active=fieldForByte(i)===active?'true':'false');\r\n    q('.agpe-range').textContent='0x'+hex(f.offset)+'\u20130x'+hex(f.offset+f.length-1)+' \u00b7 '+f.length+' bytes';\r\n    q('.agpe-field-name').textContent=f.name;\r\n    q('.agpe-raw').textContent=Array.from(bytes.slice(f.offset,f.offset+f.length),hex).join(' ');\r\n    q('.agpe-decoded').textContent=decoded(active);\r\n    q('.agpe-explainer').textContent=f.description;\r\n  }\r\n  root.querySelectorAll('input[name=\"agpe-v1-block\"]').forEach(radio=>radio.addEventListener('change',function(){\r\n    if(!this.checked)return;\r\n    blockSize=Number(this.value);\r\n    const count=view.getBigUint64(40,true)-view.getBigUint64(32,true)+1n;\r\n    const size=count*BigInt(blockSize);\r\n    const start=view.getBigUint64(32,true)*BigInt(blockSize);\r\n    q('.agpe-size').textContent=size===1048576n?'1 MiB':size===8388608n?'8 MiB':formatNumber(size)+' bytes';\r\n    q('.agpe-start').textContent=formatNumber(start);\r\n  }));\r\n  select(0);\r\n})();\r\n<\/script>\r\n\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-oqt7pej elementor-widget elementor-widget-text-editor\" data-id=\"oqt7pej\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<h3>Step 1: Decode the type GUID<\/h3><p>The first 16 bytes are:<\/p><p><code class=\"dtec-inline-code\">A2 A0 D0 EB E5 B9 33 44 87 C0 68 B6 B7 26 99 C7<\/code><\/p><p>The on-disk GUID representation uses little-endian byte order for its first 4-byte, 2-byte, and 2-byte components. Therefore:<\/p><ul><li><code class=\"dtec-inline-code\">A2 A0 D0 EB<\/code> becomes <code class=\"dtec-inline-code\">EBD0A0A2<\/code>.<\/li><li><code class=\"dtec-inline-code\">E5 B9<\/code> becomes <code class=\"dtec-inline-code\">B9E5<\/code>.<\/li><li><code class=\"dtec-inline-code\">33 44<\/code> becomes <code class=\"dtec-inline-code\">4433<\/code>.<\/li><li>The remaining eight bytes produce <code class=\"dtec-inline-code\">87C0-68B6B72699C7<\/code>.<\/li><\/ul><p>The complete value is the Microsoft Basic Data type GUID. See Microsoft&#8217;s <a href=\"https:\/\/learn.microsoft.com\/en-us\/openspecs\/windows_protocols\/MS-DTYP\/001eec5a-7f8b-4293-9e21-ca349392db40\" rel=\"nofollow\">GUID representation specification<\/a> for the underlying encoding.<\/p><h3>Step 2: Decode the LBA fields<\/h3><p>At relative offset <code class=\"dtec-inline-code\">0x20<\/code>, the bytes <code class=\"dtec-inline-code\">00 08 00 00 00 00 00 00<\/code> represent decimal 2048 in little-endian order.<\/p><p>At <code class=\"dtec-inline-code\">0x28<\/code>, <code class=\"dtec-inline-code\">FF 0F 00 00 00 00 00 00<\/code> represents decimal 4095. Therefore, this <strong>GPT partition entry<\/strong> describes 2,048 logical blocks, not 2,047.<\/p><p>If the device exposes 512-byte logical blocks, the starting byte offset equals <code class=\"dtec-inline-code\">2048 \u00d7 512 = 1,048,576<\/code>. If it exposes 4096-byte blocks, the corresponding offset is <code class=\"dtec-inline-code\">8,388,608<\/code>.<\/p><h3>Step 3: Decode attributes and name<\/h3><p>The example&#8217;s attribute bytes are all zero, so no attribute bits are set. At relative offset <code class=\"dtec-inline-code\">0x38<\/code>, the name starts with <code class=\"dtec-inline-code\">44 00 41 00 54 00 41 00<\/code>, which decodes to <code class=\"dtec-inline-code\">DATA<\/code> in UTF-16LE.<\/p><p>A hex editor&#8217;s ASCII column may show <code class=\"dtec-inline-code\">D.A.T.A.<\/code> because it treats the zero bytes as nonprintable characters. However, those periods are not part of the partition name.<\/p><p>Together, these steps let you move from raw bytes to a readable <strong>GPT partition entry<\/strong> without treating GUID text, LBA values, and UTF-16LE text as if they shared one encoding.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-fjjjja1 elementor-widget elementor-widget-heading\" data-id=\"fjjjja1\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">How to Validate a GPT Partition Entry<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-waeb48s elementor-widget elementor-widget-text-editor\" data-id=\"waeb48s\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>A decoded <strong>GPT partition entry<\/strong> is not necessarily a valid description of the disk. Check its fields against the GPT Header and other active entries.<\/p>\n<table><tbody><tr><td><p><strong>Check<\/strong><\/p><\/td><td><p><strong>What to verify<\/strong><\/p><\/td><td><p><strong>Why it matters<\/strong><\/p><\/td><\/tr><tr><td><p>Active slot<\/p><\/td><td><p><code class=\"dtec-inline-code\">PartitionTypeGUID<\/code> is not all zero<\/p><\/td><td><p>All-zero type marks an unused slot<\/p><\/td><\/tr><tr><td><p>LBA order<\/p><\/td><td><p><code class=\"dtec-inline-code\">StartingLBA \u2264 EndingLBA<\/code><\/p><\/td><td><p>Rejects reversed or empty ranges<\/p><\/td><\/tr><tr><td><p>Usable range<\/p><\/td><td><p>Both endpoints fall between <code class=\"dtec-inline-code\">FirstUsableLBA<\/code> and <code class=\"dtec-inline-code\">LastUsableLBA<\/code><\/p><\/td><td><p>Keeps partitions out of reserved GPT space<\/p><\/td><\/tr><tr><td><p>Overlap<\/p><\/td><td><p>Active entries describe disjoint ranges<\/p><\/td><td><p>Avoids conflicting partition descriptions<\/p><\/td><\/tr><tr><td><p>Identifiers<\/p><\/td><td><p>Appropriate nonduplicate Unique Partition GUIDs<\/p><\/td><td><p>Avoids identity conflicts<\/p><\/td><\/tr><tr><td><p>Reserved bits<\/p><\/td><td><p>Required reserved bits and bytes are zero<\/p><\/td><td><p>Checks compliance with the entry format<\/p><\/td><\/tr><\/tbody><\/table>\n<p>These checks reveal <strong>metadata consistency<\/strong>, not the original cause of a failure. A <strong>GPT partition entry<\/strong> is only one part of a broader disk-layout check. A boundary can be invalid even when its two 64-bit fields decode without error.<\/p>\n<h3>CRC32 checks cover the whole Entry Array<\/h3>\n<p>GPT does not store a CRC32 in each entry. Instead, the Header stores <code class=\"dtec-inline-code\">PartitionEntryArrayCRC32<\/code>, calculated over exactly <code class=\"dtec-inline-code\">NumberOfPartitionEntries \u00d7 SizeOfPartitionEntry<\/code> bytes. This range includes unused entry slots, but excludes any logical-block padding after the declared array length.<\/p>\n<p>If software modifies a <strong>GPT partition entry<\/strong>, it must update the Array CRC32 and then the corresponding Header CRC32. A matching checksum means that the bytes agree with the recorded checksum. It does <strong>not<\/strong> prove the partition boundaries, identifiers, or file system are correct.<\/p>\n<p>For a complete integrity review, also compare the primary and backup GPT metadata. However, do not assume that a backup always preserves an older partition layout.<\/p>\n<h3>GPT validity is not file-system validity<\/h3>\n<p>A <strong>GPT partition entry<\/strong> may accurately point to a partition whose NTFS or exFAT structures are damaged. Conversely, a deleted entry may leave much of the underlying data untouched. The partition table and the file system occupy different structural layers, so they require different checks.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-xx12c7q elementor-widget elementor-widget-heading\" data-id=\"xx12c7q\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">Missing or Corrupted GPT Partition Entry: What Changes?<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-vgdako6 elementor-widget elementor-widget-text-editor\" data-id=\"vgdako6\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>An unused slot, a deleted partition definition, and a damaged record are not identical:<\/p>\n<ul><li><strong>Unused:<\/strong> Its type GUID is zero, and a properly cleared slot has zero values in the remaining fields.<\/li><li><strong>Deleted:<\/strong> A partitioning operation removes the definition from the active GPT layout. Depending on what else the operation does, the old file-system data may remain.<\/li><li><strong>Corrupted:<\/strong> A record contains inaccurate or conflicting information, such as an incorrect LBA boundary or GUID.<\/li><\/ul>\n<p>Windows may show the affected region as Unallocated or fail to mount a volume. Still, those symptoms alone cannot identify which <strong>GPT partition entry<\/strong> field changed.<\/p>\n<p>A valid backup array can sometimes help determine the intended layout. Yet a normal deletion may update both arrays, and an outdated backup may contain obsolete addresses. Therefore, restoring a record solely because it appears in a backup is unsafe.<\/p>\n<p>If important data is at risk, avoid formatting, initializing, running destructive partition commands, or rewriting GPT metadata before preserving the source. If the drive repeatedly disconnects or reports serious read errors, stop unnecessary access.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-in4qo3d elementor-widget elementor-widget-heading\" data-id=\"in4qo3d\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">GPT Partition Entry vs. MBR Partition Entry<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-7vm7xe1 elementor-widget elementor-widget-text-editor\" data-id=\"7vm7xe1\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>The <strong>GPT partition entry<\/strong> provides more metadata than an MBR partition record, which occupies only 16 bytes.<\/p>\n<table><tbody><tr><td><p><strong>Feature<\/strong><\/p><\/td><td><p><strong>GPT<\/strong><\/p><\/td><td><p><strong>MBR<\/strong><\/p><\/td><\/tr><tr><td><p>Typical entry size<\/p><\/td><td><p>128 bytes<\/p><\/td><td><p>16 bytes<\/p><\/td><\/tr><tr><td><p>Partition type<\/p><\/td><td><p>128-bit GUID<\/p><\/td><td><p>8-bit type code<\/p><\/td><\/tr><tr><td><p>Partition identifier<\/p><\/td><td><p>Unique Partition GUID<\/p><\/td><td><p>No equivalent per-entry GUID<\/p><\/td><\/tr><tr><td><p>Range<\/p><\/td><td><p>64-bit starting and ending LBAs<\/p><\/td><td><p>32-bit starting LBA and sector count<\/p><\/td><\/tr><tr><td><p>Name<\/p><\/td><td><p>UTF-16LE field<\/p><\/td><td><p>No partition-name field<\/p><\/td><\/tr><tr><td><p>Built-in metadata redundancy<\/p><\/td><td><p>Primary and backup structures<\/p><\/td><td><p>No built-in backup partition table<\/p><\/td><\/tr><\/tbody><\/table>\n<p>MBR supports extended partitions to provide additional logical volumes. GPT instead uses an array whose slot count is declared in the Header. See the <a href=\"https:\/\/www.amagicsoft.com\/wiki\/mbr-partition-table.html\">MBR partition table<\/a> for its record format.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-45783ef elementor-widget elementor-widget-html\" data-id=\"45783ef\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"html.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<!doctype html>\r\n<html lang=\"en\">\r\n<head>\r\n<meta charset=\"utf-8\">\r\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\r\n<title>GPT vs. MBR \u2014 Interactive Partition Table Explorer<\/title>\r\n<style>\r\n  :root{\r\n    --ink:#203247;--muted:#617286;--line:#d8e1eb;--paper:#f5f8fc;--white:#fff;\r\n    --gpt:#2f75b5;--gpt-soft:#e6f1fc;--gpt-mid:#b9d7f3;\r\n    --mbr:#b96a28;--mbr-soft:#fff0e2;--mbr-mid:#f4d0ad;\r\n    --green:#2f8057;--green-soft:#e7f5ed;--gray-soft:#edf1f5;\r\n  }\r\n  *{box-sizing:border-box}\r\n  .gpt-mbr-lab{font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,\"Segoe UI\",sans-serif;color:var(--ink);background:var(--paper);border:1px solid var(--line);border-radius:18px;padding:clamp(14px,2.4vw,28px);max-width:1120px;margin:0 auto;line-height:1.5}\r\n  .gpt-mbr-lab h2,.gpt-mbr-lab h3,.gpt-mbr-lab p{margin-top:0}\r\n  .gpt-mbr-lab h2{font-size:clamp(22px,3vw,30px);line-height:1.2;margin-bottom:8px;letter-spacing:-.025em}\r\n  .gpt-mbr-lab h3{font-size:18px;line-height:1.3;margin-bottom:8px}\r\n  .gpt-mbr-lab p{color:var(--muted);font-size:14px;margin-bottom:0}\r\n  .gml-kicker{font-size:11px;font-weight:800;text-transform:uppercase;letter-spacing:.12em;color:var(--muted);margin-bottom:8px}\r\n  .gml-head{display:flex;justify-content:space-between;gap:18px;align-items:flex-start;margin-bottom:22px}\r\n  .gml-chip{display:inline-flex;align-items:center;gap:7px;border:1px solid var(--line);background:#fff;border-radius:999px;padding:7px 11px;font-size:12px;font-weight:700;white-space:nowrap}\r\n  .gml-dot{width:8px;height:8px;border-radius:50%;display:inline-block}\r\n  .gml-layouts{display:grid;grid-template-columns:1fr 1fr;gap:16px}\r\n  .gml-card{background:var(--white);border:1px solid var(--line);border-radius:15px;overflow:hidden;min-width:0}\r\n  .gml-card-head{padding:17px 18px 14px;border-bottom:1px solid var(--line)}\r\n  .gml-titleline{display:flex;align-items:center;justify-content:space-between;gap:10px;margin-bottom:5px}\r\n  .gml-titleline h3{margin:0}\r\n  .gml-label{font-size:11px;font-weight:800;padding:5px 8px;border-radius:7px;white-space:nowrap}\r\n  .gml-gpt .gml-label{color:var(--gpt);background:var(--gpt-soft)}\r\n  .gml-mbr .gml-label{color:var(--mbr);background:var(--mbr-soft)}\r\n  .gml-card-body{padding:16px 18px 18px}\r\n  .gml-section-label{font-size:11px;text-transform:uppercase;letter-spacing:.08em;color:var(--muted);font-weight:800;margin:0 0 9px}\r\n  .gml-disk{display:flex;gap:4px;min-height:95px;margin-bottom:12px}\r\n  .gml-seg{border:1px solid transparent;border-radius:8px;display:flex;flex-direction:column;justify-content:center;align-items:center;text-align:center;min-width:0;padding:7px 3px;cursor:pointer;font:inherit;transition:transform .12s,border-color .12s,box-shadow .12s}\r\n  .gml-seg:hover,.gml-seg:focus-visible{transform:translateY(-2px);outline:2px solid currentColor;outline-offset:1px}\r\n  .gml-seg strong{font-size:11px;line-height:1.25}\r\n  .gml-seg small{font-size:9px;line-height:1.25;margin-top:4px;opacity:.9}\r\n  .gml-gpt .gml-seg{background:var(--gpt-soft);border-color:#b9d5ef;color:#234f7d}\r\n  .gml-gpt .gml-seg:nth-child(4){background:#f2f6fa;border-color:#d8e1eb;color:#506174}\r\n  .gml-mbr .gml-seg{background:var(--mbr-soft);border-color:#efc9a6;color:#854716}\r\n  .gml-mbr .gml-seg:nth-child(2){background:#f9e0c8}\r\n  .gml-mbr .gml-seg:nth-child(4){background:#f2f6fa;border-color:#d8e1eb;color:#506174}\r\n  .gml-hint{font-size:12px!important;margin-bottom:15px!important}\r\n  .gml-inspector{border-radius:10px;background:#f7f9fc;border:1px solid var(--line);padding:12px 13px;min-height:88px}\r\n  .gml-inspector strong{display:block;font-size:13px;margin-bottom:4px}\r\n  .gml-inspector span{display:block;color:var(--muted);font-size:12px}\r\n\r\n  .gpt-mbr-lab .gml-interaction-hint{display:flex;align-items:center;gap:7px;font-size:11px;font-weight:750;color:var(--muted);margin:0 0 8px}\r\n  .gpt-mbr-lab .gml-interaction-hint:before{content:\"\";display:inline-block;width:7px;height:7px;border-radius:50%;background:currentColor;opacity:.7;flex:0 0 7px}\r\n  .gpt-mbr-lab .gml-gpt .gml-interaction-hint{color:var(--gpt)}\r\n  .gpt-mbr-lab .gml-mbr .gml-interaction-hint{color:var(--mbr)}\r\n\r\n\r\n  .gpt-mbr-lab .gml-field-instruction{\r\n    display:flex;align-items:center;gap:8px;\r\n    margin:12px 0 10px;padding:9px 12px;\r\n    border:1px solid var(--line);border-radius:9px;\r\n    background:#fff;color:var(--muted);\r\n    font-size:12px;font-weight:750;line-height:1.4\r\n  }\r\n  .gpt-mbr-lab .gml-field-instruction:before{\r\n    content:\"\";display:inline-block;width:8px;height:8px;flex:0 0 8px;\r\n    border-radius:50%;background:var(--gpt)\r\n  }\r\n\r\n  .gml-records{margin-top:22px}\r\n  .gml-records-head{display:flex;justify-content:space-between;align-items:end;gap:16px;margin-bottom:12px}\r\n  .gml-records-head h3{margin:0}\r\n  .gml-record-grid{display:grid;grid-template-columns:1fr 1fr;gap:16px}\r\n  .gml-record{background:#fff;border:1px solid var(--line);border-radius:15px;padding:16px;min-width:0}\r\n  .gml-record h4{margin:0 0 5px;font-size:15px}\r\n  .gml-record p{font-size:12px;margin-bottom:13px}\r\n  .gml-bytes{display:flex;gap:3px;min-height:88px;margin:12px 0}\r\n  .gml-byte{border:1px solid;border-radius:6px;display:flex;flex-direction:column;justify-content:center;align-items:center;text-align:center;min-width:0;padding:5px 3px;cursor:pointer;font:inherit;flex:1}\r\n  .gml-byte strong{font-size:11px;line-height:1.25}\r\n  .gml-byte small{font-size:9px;line-height:1.25;margin-top:5px}\r\n  .gml-gpt .gml-byte{background:var(--gpt-soft);border-color:#b9d5ef;color:#234f7d}\r\n  .gml-mbr .gml-byte{background:var(--mbr-soft);border-color:#efc9a6;color:#854716}\r\n  .gml-byte[aria-pressed=\"true\"]{outline:2px solid currentColor;outline-offset:2px}\r\n  .gml-record .gml-inspector{min-height:76px}\r\n  .gml-facts{margin-top:22px;border:1px solid var(--line);background:#fff;border-radius:15px;overflow:hidden}\r\n  .gml-facts h3{padding:16px 18px;margin:0;border-bottom:1px solid var(--line)}\r\n  .gml-table{width:100%;border-collapse:collapse;font-size:13px}\r\n  .gml-table th,.gml-table td{text-align:left;padding:11px 14px;border-bottom:1px solid #e7edf3;vertical-align:top}\r\n  .gml-table th{background:#f7f9fc;font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted)}\r\n  .gml-table tr:last-child td{border-bottom:0}\r\n  .gml-table td:first-child{font-weight:700;width:25%}\r\n  .gml-note{display:flex;gap:11px;padding:14px 16px;margin-top:14px;background:var(--green-soft);border:1px solid #c7e6d3;border-radius:12px}\r\n  .gml-note b{font-size:13px;display:block;margin-bottom:3px;color:#245b3e}\r\n  .gml-note p{font-size:12px;color:#3f6952}\r\n  .gml-foot{font-size:11px!important;margin-top:12px!important}\r\n\r\n  .gml-size-scale{background:#fff;border:1px solid var(--line);border-radius:13px;padding:14px 15px;margin:0 0 14px}\r\n  .gml-size-scale h4{font-size:13px;margin:0 0 10px}\r\n  .gml-scale-row{display:grid;grid-template-columns:86px minmax(0,1fr);gap:10px;align-items:center;margin:8px 0}\r\n  .gml-scale-label{font-size:11px;font-weight:800;color:var(--ink)}\r\n  .gml-scale-track{height:30px;display:flex;align-items:stretch;gap:2px;min-width:0}\r\n  .gml-scale-segment{display:flex;align-items:center;justify-content:center;min-width:0;overflow:hidden;border:1px solid;border-radius:4px;font-size:9px;font-weight:800;white-space:nowrap}\r\n  .gml-scale-gpt .gml-scale-segment{background:var(--gpt-soft);border-color:#b9d5ef;color:#234f7d}\r\n  .gml-scale-mbr .gml-scale-segment{background:var(--mbr-soft);border-color:#efc9a6;color:#854716}\r\n  .gml-scale-mbr .gml-scale-track{width:12.5%;min-width:0}\r\n  .gml-scale-legend{display:flex;flex-wrap:wrap;gap:6px 12px;margin:10px 0 0 96px}\r\n  .gml-scale-legend span{font-size:10px;color:var(--muted)}\r\n  .gml-scale-legend b{color:var(--ink)}\r\n  .gml-scale-caption{font-size:11px!important;margin-top:8px!important}\r\n  @media(max-width:760px){\r\n    .gml-scale-row{grid-template-columns:72px minmax(0,1fr);gap:7px}\r\n    .gml-scale-legend{margin-left:79px}\r\n    .gml-scale-segment{font-size:8px}\r\n  }\r\n  @media(max-width:430px){\r\n    .gml-scale-label{font-size:10px}\r\n    .gml-scale-row{grid-template-columns:62px minmax(0,1fr);gap:6px}\r\n    .gml-scale-legend{margin-left:68px;gap:5px 9px}\r\n    .gml-scale-segment{font-size:7px}\r\n  }\r\n\r\n  @media(max-width:760px){\r\n    .gml-head{display:block}.gml-chip{margin-top:13px}\r\n    .gml-layouts,.gml-record-grid{grid-template-columns:1fr}\r\n    .gml-card-head{padding:15px}.gml-card-body{padding:14px}\r\n    .gml-disk{min-height:100px}\r\n    .gml-seg strong{font-size:10px}.gml-seg small{font-size:8px}\r\n    .gml-records-head{display:block}.gml-records-head p{margin-top:5px}\r\n    .gml-table th,.gml-table td{padding:9px 8px;font-size:12px}\r\n    .gml-table td:first-child{width:27%}\r\n  }\r\n  @media(max-width:430px){\r\n    .gml-disk{gap:2px;min-height:112px}\r\n    .gml-seg{padding:5px 1px}\r\n    .gml-seg strong{font-size:9px;overflow-wrap:anywhere}\r\n    .gml-seg small{font-size:7px}\r\n    .gml-bytes{gap:2px}\r\n    .gml-byte{padding:4px 1px}\r\n    .gml-byte strong{font-size:10px}\r\n    .gml-byte small{font-size:8px}\r\n  }\r\n<\/style>\r\n<\/head>\r\n<body style=\"margin:0;padding:12px;background:#fff\">\r\n<section class=\"gpt-mbr-lab\" aria-label=\"Interactive GPT versus MBR comparison\">\r\n  <div class=\"gml-head\">\r\n    <div>\r\n      <div class=\"gml-kicker\">Interactive storage guide<\/div>\r\n      <h2>GPT vs. MBR: See the Structural Difference<\/h2>\r\n      <p>Compare the disk layouts and inspect the structure of each partition record.<\/p>\r\n    <\/div>\r\n    <div class=\"gml-chip\"><span class=\"gml-dot\" style=\"background:#2f75b5\"><\/span>GPT <span style=\"color:#9aa8b7\">vs.<\/span> <span class=\"gml-dot\" style=\"background:#b96a28\"><\/span>MBR<\/div>\r\n  <\/div>\r\n\r\n  <div class=\"gml-layouts\">\r\n    <article class=\"gml-card gml-gpt\">\r\n      <div class=\"gml-card-head\">\r\n        <div class=\"gml-titleline\"><h3>GPT disk layout<\/h3><span class=\"gml-label\">Modern structure<\/span><\/div>\r\n        <p>Primary and backup metadata; partition records live in arrays.<\/p>\r\n      <\/div>\r\n      <div class=\"gml-card-body\">\r\n        <div class=\"gml-section-label\">Disk regions \u00b7 select a region<\/div>\r\n        <div class=\"gml-disk\" role=\"group\" aria-label=\"GPT disk regions\">\r\n          <button class=\"gml-seg\" style=\"flex:.8\" data-inspect=\"gpt-layout\" data-title=\"Protective MBR \u00b7 LBA 0\" data-desc=\"A compatibility record helps older MBR-only tools recognize that the disk is in use. It does not replace the GPT partition entries.\"><strong>Protective<br>MBR<\/strong><small>LBA 0<\/small><\/button>\r\n          <button class=\"gml-seg\" style=\"flex:.8\" data-inspect=\"gpt-layout\" data-title=\"Primary GPT Header \u00b7 LBA 1\" data-desc=\"Stores disk-level metadata, including the disk GUID, usable LBA range, primary Entry Array location, entry count, entry size, and CRC32 values.\"><strong>GPT<br>Header<\/strong><small>LBA 1<\/small><\/button>\r\n          <button class=\"gml-seg\" style=\"flex:1.15\" data-inspect=\"gpt-layout\" data-title=\"Primary Entry Array\" data-desc=\"Contains consecutive partition-entry slots. A common configuration uses 128 entries of 128 bytes each, but the Header defines the actual count and size.\"><strong>Entry<br>Array<\/strong><small>After Header<\/small><\/button>\r\n          <button class=\"gml-seg\" style=\"flex:2.5\" data-inspect=\"gpt-layout\" data-title=\"Usable partition area\" data-desc=\"Active entries describe non-overlapping LBA ranges in the usable area. The partition contents may contain NTFS, FAT32, exFAT, or another data layout.\"><strong>Usable partition area<\/strong><small>Partition data<\/small><\/button>\r\n          <button class=\"gml-seg\" style=\"flex:1.15\" data-inspect=\"gpt-layout\" data-title=\"Backup Entry Array\" data-desc=\"Stores the backup copy of the partition entries near the end of the disk. Its position is described by the backup GPT Header.\"><strong>Backup<br>Array<\/strong><small>Near end<\/small><\/button>\r\n          <button class=\"gml-seg\" style=\"flex:.8\" data-inspect=\"gpt-layout\" data-title=\"Backup GPT Header\" data-desc=\"Normally occupies the final logical block and describes the backup metadata. It provides a second copy of GPT information, not a backup of the partition's files.\"><strong>Backup<br>Header<\/strong><small>Last LBA<\/small><\/button>\r\n        <\/div>\r\n        <p class=\"gml-hint\">Common GPT layout. Exact array locations and sizes are defined by the headers.<\/p>\r\n        <div class=\"gml-inspector\" id=\"gpt-layout-inspector\" aria-live=\"polite\">\r\n          <strong>Choose a GPT region<\/strong><span>Click any block above to inspect its role.<\/span>\r\n        <\/div>\r\n      <\/div>\r\n    <\/article>\r\n\r\n    <article class=\"gml-card gml-mbr\">\r\n      <div class=\"gml-card-head\">\r\n        <div class=\"gml-titleline\"><h3>MBR disk layout<\/h3><span class=\"gml-label\">Legacy structure<\/span><\/div>\r\n        <p>The first sector contains boot code and four partition-table entries.<\/p>\r\n      <\/div>\r\n      <div class=\"gml-card-body\">\r\n        <div class=\"gml-section-label\">Disk regions \u00b7 select a region<\/div>\r\n        <div class=\"gml-disk\" role=\"group\" aria-label=\"MBR disk regions\">\r\n          <button class=\"gml-seg\" style=\"flex:1.15\" data-inspect=\"mbr-layout\" data-title=\"MBR sector \u00b7 LBA 0\" data-desc=\"The first sector contains bootstrap code, disk signature and four 16-byte partition records, followed by the 0x55AA signature at the end of the sector.\"><strong>MBR<br>sector<\/strong><small>LBA 0<\/small><\/button>\r\n          <button class=\"gml-seg\" style=\"flex:1.2\" data-inspect=\"mbr-layout\" data-title=\"Primary partition\" data-desc=\"Each of the four MBR table slots can describe a primary partition or an extended partition. The table has four slots, not four slots per disk region.\"><strong>Primary<br>partition<\/strong><small>Data<\/small><\/button>\r\n          <button class=\"gml-seg\" style=\"flex:1.2\" data-inspect=\"mbr-layout\" data-title=\"Primary partition\" data-desc=\"Another MBR table slot may describe a second primary partition. The actual layout depends on the partition records stored in LBA 0.\"><strong>Primary<br>partition<\/strong><small>Data<\/small><\/button>\r\n          <button class=\"gml-seg\" style=\"flex:1.35\" data-inspect=\"mbr-layout\" data-title=\"Extended partition (optional)\" data-desc=\"One MBR entry can designate an extended partition. Linked Extended Boot Records (EBRs) can describe logical partitions within that region, allowing more volumes than the four top-level slots alone suggest.\"><strong>Extended<br>partition<\/strong><small>Optional<\/small><\/button>\r\n          <button class=\"gml-seg\" style=\"flex:1.2\" data-inspect=\"mbr-layout\" data-title=\"Remaining disk space\" data-desc=\"The remaining area may contain another primary partition, logical partitions inside an extended partition, or unallocated space. MBR does not provide a built-in backup partition table at the end of the disk.\"><strong>Other \/<br>free space<\/strong><small>Depends<\/small><\/button>\r\n        <\/div>\r\n        <p class=\"gml-hint\">Conceptual MBR layout. Extended partitions are optional.<\/p>\r\n        <div class=\"gml-inspector\" id=\"mbr-layout-inspector\" aria-live=\"polite\">\r\n          <strong>Choose an MBR region<\/strong><span>Click any block above to inspect its role.<\/span>\r\n        <\/div>\r\n      <\/div>\r\n    <\/article>\r\n  <\/div>\r\n\r\n  <section class=\"gml-records\">\r\n    <div class=\"gml-records-head\">\r\n      <div><div class=\"gml-kicker\">Record structure comparison<\/div><h3>Partition record fields: 128 bytes vs. 16 bytes<\/h3><\/div>\r\n    <\/div>\r\n\r\n    <div class=\"gml-size-scale\" aria-label=\"Partition record size comparison\">\r\n      <h4>Record size at a common scale<\/h4>\r\n      <div class=\"gml-scale-row gml-scale-gpt\">\r\n        <div class=\"gml-scale-label\">GPT \u00b7 128 B<\/div>\r\n        <div class=\"gml-scale-track\" aria-label=\"GPT record: 128 bytes\">\r\n          <div class=\"gml-scale-segment\" style=\"flex:16\" title=\"Partition Type GUID: 16 bytes\">Type<\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:16\" title=\"Unique Partition GUID: 16 bytes\">Unique<\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:8\" title=\"Starting LBA: 8 bytes\">S<\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:8\" title=\"Ending LBA: 8 bytes\">E<\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:8\" title=\"Attributes: 8 bytes\">A<\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:72\" title=\"Partition Name: 72 bytes\">Partition Name<\/div>\r\n        <\/div>\r\n      <\/div>\r\n      <div class=\"gml-scale-row gml-scale-mbr\">\r\n        <div class=\"gml-scale-label\">MBR \u00b7 16 B<\/div>\r\n        <div class=\"gml-scale-track\" aria-label=\"MBR record: 16 bytes\">\r\n          <div class=\"gml-scale-segment\" style=\"flex:1\" title=\"Status: 1 byte\"><\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:3\" title=\"Starting CHS: 3 bytes\"><\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:1\" title=\"Partition Type: 1 byte\"><\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:3\" title=\"Ending CHS: 3 bytes\"><\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:4\" title=\"Starting LBA: 4 bytes\"><\/div>\r\n          <div class=\"gml-scale-segment\" style=\"flex:4\" title=\"Sector count: 4 bytes\"><\/div>\r\n        <\/div>\r\n      <\/div>\r\n      <div class=\"gml-scale-legend\">\r\n        <span><b>GPT:<\/b> 16 + 16 + 8 + 8 + 8 + 72 = 128 bytes<\/span>\r\n        <span><b>MBR:<\/b> 1 + 3 + 1 + 3 + 4 + 4 = 16 bytes<\/span>\r\n      <\/div>\r\n      <p class=\"gml-scale-caption\">At this shared scale, one GPT entry is eight times the size of one MBR entry. The colored field blocks in the two cards below are interactive.<\/p>\r\n    <\/div>\r\n\r\n    <div class=\"gml-field-instruction\">Select a colored field below to inspect its size and purpose.<\/div>\r\n    <div class=\"gml-record-grid\">\r\n      <article class=\"gml-record gml-gpt\">\r\n        <h4>GPT partition entry \u00b7 128 bytes (common)<\/h4>\r\n        <p>Six defined fields describe type, identity, boundaries, attributes, and name.<\/p>\r\n        <div class=\"gml-bytes\" role=\"group\" aria-label=\"GPT entry fields\">\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"gpt-field\" data-title=\"Partition Type GUID \u00b7 16 bytes\" data-desc=\"Identifies the intended partition type, such as Microsoft Basic Data or EFI System Partition.\"><strong>Type GUID<\/strong><small>16 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"gpt-field\" data-title=\"Unique Partition GUID \u00b7 16 bytes\" data-desc=\"Identifies this particular partition. It is different from the type GUID and the disk GUID stored in the Header.\"><strong>Unique GUID<\/strong><small>16 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-title=\"Starting LBA \u00b7 8 bytes\" data-desc=\"Unsigned 64-bit little-endian value identifying the first logical block of the partition.\" data-inspect=\"gpt-field\"><strong>Start LBA<\/strong><small>8 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"gpt-field\" data-title=\"Ending LBA \u00b7 8 bytes\" data-desc=\"Unsigned 64-bit little-endian value identifying the last logical block, inclusive.\"><strong>End LBA<\/strong><small>8 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"gpt-field\" data-title=\"Attributes \u00b7 8 bytes\" data-desc=\"A 64-bit attribute mask. Some bits have UEFI-defined meanings; high bits may be defined for particular partition types.\"><strong>Attributes<\/strong><small>8 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"gpt-field\" data-title=\"Partition Name \u00b7 72 bytes\" data-desc=\"Stores up to 36 UTF-16 code units. This name is not necessarily the same as the file-system volume label.\"><strong>Name<\/strong><small>72 B<\/small><\/button>\r\n        <\/div>\r\n        <div class=\"gml-inspector\" id=\"gpt-field-inspector\" aria-live=\"polite\"><strong>Select a GPT field<\/strong><span>Its length, encoding, and purpose will appear here.<\/span><\/div>\r\n      <\/article>\r\n\r\n      <article class=\"gml-record gml-mbr\">\r\n        <h4>MBR partition entry \u00b7 16 bytes<\/h4>\r\n        <p>Four slots are stored in the MBR sector. Each slot uses a compact legacy record.<\/p>\r\n        <div class=\"gml-bytes\" role=\"group\" aria-label=\"MBR entry fields\">\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"mbr-field\" data-title=\"Status \u00b7 1 byte\" data-desc=\"Legacy boot-status field. The conventional active flag is 0x80; this is not a GUID or file-system identifier.\"><strong>Status<\/strong><small>1 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"mbr-field\" data-title=\"Starting CHS \u00b7 3 bytes\" data-desc=\"Legacy Cylinder-Head-Sector address. Modern systems generally rely on the LBA fields; CHS values may be saturated or otherwise not useful for describing large disks.\"><strong>Start CHS<\/strong><small>3 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"mbr-field\" data-title=\"Partition Type \u00b7 1 byte\" data-desc=\"An 8-bit type code indicating the partition category. Unlike GPT, this is not a 128-bit GUID.\"><strong>Type<\/strong><small>1 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"mbr-field\" data-title=\"Ending CHS \u00b7 3 bytes\" data-desc=\"Legacy CHS address for the ending position. It is part of the 16-byte record, alongside the LBA-based fields.\"><strong>End CHS<\/strong><small>3 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"mbr-field\" data-title=\"Starting LBA \u00b7 4 bytes\" data-desc=\"A 32-bit starting LBA value. With traditional 512-byte logical sectors, MBR's 32-bit LBA scheme leads to the familiar roughly 2 TiB addressing limit.\"><strong>Start LBA<\/strong><small>4 B<\/small><\/button>\r\n          <button class=\"gml-byte\" aria-pressed=\"false\" data-inspect=\"mbr-field\" data-title=\"Sector count \u00b7 4 bytes\" data-desc=\"A 32-bit count of sectors in the partition. Unlike GPT, MBR stores a start address plus a sector count rather than start and inclusive end LBAs.\"><strong>Sector count<\/strong><small>4 B<\/small><\/button>\r\n        <\/div>\r\n        <div class=\"gml-inspector\" id=\"mbr-field-inspector\" aria-live=\"polite\"><strong>Select an MBR field<\/strong><span>Its length, encoding, and purpose will appear here.<\/span><\/div>\r\n      <\/article>\r\n    <\/div>\r\n  <\/section>\r\n\r\n  <section class=\"gml-facts\">\r\n    <h3>What changes when you use GPT instead of MBR?<\/h3>\r\n    <table class=\"gml-table\">\r\n      <thead><tr><th>Feature<\/th><th>GPT<\/th><th>MBR<\/th><\/tr><\/thead>\r\n      <tbody>\r\n        <tr><td>Record size<\/td><td>128 bytes is common; Header defines entry size and count.<\/td><td>16 bytes per entry; four top-level slots in the MBR.<\/td><\/tr>\r\n        <tr><td>Partition type<\/td><td>128-bit GUID<\/td><td>8-bit type code<\/td><\/tr>\r\n        <tr><td>Addressing<\/td><td>64-bit starting and ending LBA<\/td><td>32-bit starting LBA and sector count<\/td><\/tr>\r\n        <tr><td>Partition count<\/td><td>Depends on the Entry Array size<\/td><td>Four primary-table slots; one may be an extended partition<\/td><\/tr>\r\n        <tr><td>Metadata redundancy<\/td><td>Primary and backup GPT metadata<\/td><td>No built-in backup partition table<\/td><\/tr>\r\n      <\/tbody>\r\n    <\/table>\r\n  <\/section>\r\n\r\n  <div class=\"gml-note\">\r\n    <div aria-hidden=\"true\" style=\"font-size:20px;line-height:1\">\u2713<\/div>\r\n    <div><b>The key distinction<\/b><p>GPT is not simply a larger partition record. It uses a Header-defined array, GUID-based identifiers, 64-bit LBA boundaries, and backup metadata. MBR uses a compact 16-byte record and a four-slot table in the first sector.<\/p><\/div>\r\n  <\/div>\r\n  <p class=\"gml-foot\">Teaching example based on the GPT format defined by UEFI and the legacy MBR partition-record layout. The diagrams summarize structure; they do not read or modify a disk.<\/p>\r\n<\/section>\r\n<script>\r\n(function(){\r\n  const root = document.querySelector('.gpt-mbr-lab');\r\n  if(!root) return;\r\n  root.querySelectorAll('[data-inspect]').forEach(function(btn){\r\n    btn.addEventListener('click', function(){\r\n      const kind = btn.getAttribute('data-inspect');\r\n      const title = btn.getAttribute('data-title') || 'Selected field';\r\n      const desc = btn.getAttribute('data-desc') || '';\r\n      const targetId = kind + '-inspector';\r\n      const target = root.querySelector('#' + targetId);\r\n      if(target){\r\n        target.innerHTML = '';\r\n        const strong = document.createElement('strong');\r\n        strong.textContent = title;\r\n        const span = document.createElement('span');\r\n        span.textContent = desc;\r\n        target.appendChild(strong);\r\n        target.appendChild(span);\r\n      }\r\n      if(kind === 'gpt-field' || kind === 'mbr-field'){\r\n        const group = btn.closest('.gml-bytes');\r\n        if(group){\r\n          group.querySelectorAll('button').forEach(function(b){b.setAttribute('aria-pressed', b === btn ? 'true' : 'false');});\r\n        }\r\n      }\r\n    });\r\n  });\r\n})();\r\n<\/script>\r\n<\/body>\r\n<\/html>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-pvpi1at elementor-widget elementor-widget-heading\" data-id=\"pvpi1at\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">Conclusion<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-g16101x elementor-widget elementor-widget-text-editor\" data-id=\"g16101x\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"text-editor.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t\t\t\t\t<p>A <strong>GPT partition entry<\/strong> connects a partition&#8217;s identity to its logical-block range. Its six fields explain what the partition is meant to be, where it resides, and which attributes apply. By combining the <strong>GPT partition entry structure<\/strong>, Header-defined array offsets, GUID decoding, and boundary checks, you can interpret GPT metadata without confusing it with the file system or assuming that a valid CRC32 proves the data is healthy.<\/p>\t\t\t\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-3puqvgh elementor-widget elementor-widget-heading\" data-id=\"3puqvgh\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"heading.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<h2 class=\"elementor-heading-title elementor-size-default\">FAQ<\/h2>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<div class=\"elementor-element elementor-element-15ohshv faq-no-toc dtec-faq elementor-widget elementor-widget-elementskit-faq\" data-id=\"15ohshv\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"elementskit-faq.default\">\n\t\t\t\t<div class=\"elementor-widget-container\">\n\t\t\t\t\t<div class=\"ekit-wid-con\" >\n                <div class=\"elementskit-single-faq elementor-repeater-item-brpo8e3\">\n            <div class=\"elementskit-faq-header\">\n                <h3 class=\"elementskit-faq-title\">Is every GPT partition entry exactly 128 bytes?<\/h3>\n            <\/div>\n            <div class=\"elementskit-faq-body\">\n                No. UEFI 2.10 permits entry sizes of <code>128 \u00d7 2^n<\/code> bytes. The Header's <code>SizeOfPartitionEntry<\/code> field tells a parser the actual size. Thus, a parser that always jumps forward exactly 128 bytes may read larger entries incorrectly.            <\/div>\n        <\/div>\n                <div class=\"elementskit-single-faq elementor-repeater-item-5he55tr\">\n            <div class=\"elementskit-faq-header\">\n                <h3 class=\"elementskit-faq-title\">Can a GPT partition entry array hold more than 128 partitions?<\/h3>\n            <\/div>\n            <div class=\"elementskit-faq-body\">\n                Yes. Many disks reserve 128 slots by default, but the Header controls their number. A larger array can support more slots, subject to applicable specification and implementation constraints. An allocated slot does not automatically mean that an active partition uses it.            <\/div>\n        <\/div>\n                <div class=\"elementskit-single-faq elementor-repeater-item-8u65t4d\">\n            <div class=\"elementskit-faq-header\">\n                <h3 class=\"elementskit-faq-title\">Does the GPT partition type GUID tell me whether a partition is NTFS?<\/h3>\n            <\/div>\n            <div class=\"elementskit-faq-body\">\n                No. A Microsoft Basic Data Type GUID does not distinguish NTFS from FAT32 or exFAT. You need evidence from the file-system structures inside the partition. Also, the GUID describes intended purpose, not the health of the contained file system.            <\/div>\n        <\/div>\n                <div class=\"elementskit-single-faq elementor-repeater-item-hbpni3s\">\n            <div class=\"elementskit-faq-header\">\n                <h3 class=\"elementskit-faq-title\">Why does the GUID appear reversed in a hex editor?<\/h3>\n            <\/div>\n            <div class=\"elementskit-faq-body\">\n                A GUID's first three binary fields use little-endian ordering. Therefore, a hex editor displays those bytes differently from the standard GUID text. Interpret them by field boundaries rather than reversing all 16 bytes as a single unit.            <\/div>\n        <\/div>\n                <div class=\"elementskit-single-faq elementor-repeater-item-siuwzxg\">\n            <div class=\"elementskit-faq-header\">\n                <h3 class=\"elementskit-faq-title\">Is the GPT Partition Name the same as a volume label?<\/h3>\n            <\/div>\n            <div class=\"elementskit-faq-body\">\n                No. The partition name is part of the GPT entry, whereas the volume label belongs to the file system. Their values can differ. Changing a label does not inherently update the GPT name.            <\/div>\n        <\/div>\n                <div class=\"elementskit-single-faq elementor-repeater-item-gbmg2ii\">\n            <div class=\"elementskit-faq-header\">\n                <h3 class=\"elementskit-faq-title\">Can a GPT partition entry pass CRC32 validation but still be wrong?<\/h3>\n            <\/div>\n            <div class=\"elementskit-faq-body\">\n                Yes. The Entry Array checksum checks stored bytes against a checksum in the Header. It does not check whether LBA ranges overlap, GUIDs identify the intended partitions, or file-system structures remain usable. You must assess these separately.            <\/div>\n        <\/div>\n                <div class=\"elementskit-single-faq elementor-repeater-item-2fgtxkd\">\n            <div class=\"elementskit-faq-header\">\n                <h3 class=\"elementskit-faq-title\">Does deleting a GPT partition entry erase the files?<\/h3>\n            <\/div>\n            <div class=\"elementskit-faq-body\">\n                Not necessarily. Removing the definition can leave its former data blocks intact, but additional formatting, overwriting, or other device operations may destroy data. Never infer recoverability from a missing entry alone, and avoid writing to a disk that contains important lost data.            <\/div>\n        <\/div>\n                                <script type=\"application\/ld+json\">{\"@context\":\"https:\/\/schema.org\",\"@type\":\"FAQPage\",\"mainEntity\":[{\"@type\":\"Question\",\"name\":\"Is every GPT partition entry exactly 128 bytes?\",\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"No. UEFI 2.10 permits entry sizes of <code>128 \u00d7 2^n<\/code> bytes. The Header's <code>SizeOfPartitionEntry<\/code> field tells a parser the actual size. Thus, a parser that always jumps forward exactly 128 bytes may read larger entries incorrectly.\"}},{\"@type\":\"Question\",\"name\":\"Can a GPT partition entry array hold more than 128 partitions?\",\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"Yes. Many disks reserve 128 slots by default, but the Header controls their number. A larger array can support more slots, subject to applicable specification and implementation constraints. An allocated slot does not automatically mean that an active partition uses it.\"}},{\"@type\":\"Question\",\"name\":\"Does the GPT partition type GUID tell me whether a partition is NTFS?\",\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"No. A Microsoft Basic Data Type GUID does not distinguish NTFS from FAT32 or exFAT. You need evidence from the file-system structures inside the partition. Also, the GUID describes intended purpose, not the health of the contained file system.\"}},{\"@type\":\"Question\",\"name\":\"Why does the GUID appear reversed in a hex editor?\",\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"A GUID's first three binary fields use little-endian ordering. Therefore, a hex editor displays those bytes differently from the standard GUID text. Interpret them by field boundaries rather than reversing all 16 bytes as a single unit.\"}},{\"@type\":\"Question\",\"name\":\"Is the GPT Partition Name the same as a volume label?\",\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"No. The partition name is part of the GPT entry, whereas the volume label belongs to the file system. Their values can differ. Changing a label does not inherently update the GPT name.\"}},{\"@type\":\"Question\",\"name\":\"Can a GPT partition entry pass CRC32 validation but still be wrong?\",\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"Yes. The Entry Array checksum checks stored bytes against a checksum in the Header. It does not check whether LBA ranges overlap, GUIDs identify the intended partitions, or file-system structures remain usable. You must assess these separately.\"}},{\"@type\":\"Question\",\"name\":\"Does deleting a GPT partition entry erase the files?\",\"acceptedAnswer\":{\"@type\":\"Answer\",\"text\":\"Not necessarily. Removing the definition can leave its former data blocks intact, but additional formatting, overwriting, or other device operations may destroy data. Never infer recoverability from a missing entry alone, and avoid writing to a disk that contains important lost data.\"}}]}<\/script>\n                \n    <\/div>\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"<p>A GPT partition entry is a record that describes one partition on a GUID Partition Table (GPT) disk. It identifies the partition&#8217;s type, unique GUID, starting and ending logical block addresses (LBAs), attributes, and name. The usual GPT partition entry structure occupies 128 bytes. By decoding these fields, you can locate a partition, calculate its [&hellip;]<\/p>\n","protected":false},"author":6,"featured_media":57986,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[842],"tags":[841],"class_list":["post-57985","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-disk-partition","tag-knowledge-base"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v25.0 (Yoast SEO v27.9) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>GPT Partition Entry: Structure, Array, and GUID Fields | Amagicsoft<\/title>\n<meta name=\"description\" content=\"Understand GPT partition entry fields, GUID encoding, entry array offsets, LBA boundaries, and the limits of CRC32 validation.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.amagicsoft.com\/fr\/kb\/disk-partition\/gpt-partition-entry.html\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"GPT Partition Entry: Structure, Array, and GUID Fields\" \/>\n<meta property=\"og:description\" content=\"Understand GPT partition entry fields, GUID encoding, entry array offsets, LBA boundaries, and the limits of CRC32 validation.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.amagicsoft.com\/fr\/kb\/disk-partition\/gpt-partition-entry.html\" \/>\n<meta property=\"og:site_name\" content=\"Amagicsoft\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/amagicsoft.2024\/\" \/>\n<meta property=\"article:published_time\" content=\"2026-10-29T03:42:14+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.amagicsoft.com\/wp-content\/uploads\/2026\/10\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"1350\" \/>\n\t<meta property=\"og:image:height\" content=\"760\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"Vasilii\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@Amagicsoft\" \/>\n<meta name=\"twitter:site\" content=\"@Amagicsoft\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Vasilii\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"14 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html\"},\"author\":{\"name\":\"Vasilii\",\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/#\\\/schema\\\/person\\\/5cc725a7bfa9bc0e962db26a19dfb8c2\"},\"headline\":\"GPT Partition Entry: Structure, Array, and GUID Fields\",\"datePublished\":\"2026-10-29T03:42:14+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html\"},\"wordCount\":2800,\"publisher\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.amagicsoft.com\\\/wp-content\\\/uploads\\\/2026\\\/10\\\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp\",\"keywords\":[\"Knowledge Base\"],\"articleSection\":[\"Disk &amp; Partition\"],\"inLanguage\":\"fr-FR\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html\",\"url\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html\",\"name\":\"GPT Partition Entry: Structure, Array, and GUID Fields | Amagicsoft\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.amagicsoft.com\\\/wp-content\\\/uploads\\\/2026\\\/10\\\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp\",\"datePublished\":\"2026-10-29T03:42:14+00:00\",\"description\":\"Understand GPT partition entry fields, GUID encoding, entry array offsets, LBA boundaries, and the limits of CRC32 validation.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html#primaryimage\",\"url\":\"https:\\\/\\\/www.amagicsoft.com\\\/wp-content\\\/uploads\\\/2026\\\/10\\\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp\",\"contentUrl\":\"https:\\\/\\\/www.amagicsoft.com\\\/wp-content\\\/uploads\\\/2026\\\/10\\\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp\",\"width\":1350,\"height\":760,\"caption\":\"GPT Partition Entry Structure, Array, and GUID Fields\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/kb\\\/disk-partition\\\/gpt-partition-entry.html#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.amagicsoft.com\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"GPT Partition Entry: Structure, Array, and GUID Fields\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/#website\",\"url\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/\",\"name\":\"Amagicsoft\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/#organization\",\"name\":\"Amagicsoft\",\"url\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/www.amagicsoft.com\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/cropped-logo_512x512-1.webp\",\"contentUrl\":\"https:\\\/\\\/www.amagicsoft.com\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/cropped-logo_512x512-1.webp\",\"width\":512,\"height\":512,\"caption\":\"Amagicsoft\"},\"image\":{\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/amagicsoft.2024\\\/\",\"https:\\\/\\\/x.com\\\/Amagicsoft\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.amagicsoft.com\\\/zh\\\/#\\\/schema\\\/person\\\/5cc725a7bfa9bc0e962db26a19dfb8c2\",\"name\":\"Vasilii\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/12fbd3cf5c3fd435565e0ee05fea6fb3ae89413aafdccfb30c0c821c69a44d12?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/12fbd3cf5c3fd435565e0ee05fea6fb3ae89413aafdccfb30c0c821c69a44d12?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/12fbd3cf5c3fd435565e0ee05fea6fb3ae89413aafdccfb30c0c821c69a44d12?s=96&d=mm&r=g\",\"caption\":\"Vasilii\"},\"description\":\"Vasilii is a data recovery specialist with around 10 years of hands-on experience in the field. Throughout his career, he has successfully solved thousands of complex cases involving deleted files, formatted drives, lost partitions, and RAW file systems. His expertise covers both manual recovery methods using professional tools like hex editors and advanced automated solutions with recovery software. Vasilii's mission is to make reliable data recovery knowledge accessible to both IT professionals and everyday users, helping them safeguard their valuable digital assets.\",\"sameAs\":[\"https:\\\/\\\/www.linkedin.com\\\/in\\\/vasilii-zaitsev-65894b376\\\/\"],\"url\":\"https:\\\/\\\/www.amagicsoft.com\\\/fr\\\/author\\\/vasilii\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Entr\u00e9e de partition GPT : champs \u00ab Structure \u00bb, \u00ab Array \u00bb et \u00ab GUID \u00bb | Amagicsoft","description":"Comprendre les champs des entr\u00e9es de partition GPT, le codage GUID, les d\u00e9calages des tableaux d'entr\u00e9es, les limites LBA et les contraintes li\u00e9es \u00e0 la validation CRC32.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.amagicsoft.com\/fr\/kb\/disk-partition\/gpt-partition-entry.html","og_locale":"fr_FR","og_type":"article","og_title":"GPT Partition Entry: Structure, Array, and GUID Fields","og_description":"Understand GPT partition entry fields, GUID encoding, entry array offsets, LBA boundaries, and the limits of CRC32 validation.","og_url":"https:\/\/www.amagicsoft.com\/fr\/kb\/disk-partition\/gpt-partition-entry.html","og_site_name":"Amagicsoft","article_publisher":"https:\/\/www.facebook.com\/amagicsoft.2024\/","article_published_time":"2026-10-29T03:42:14+00:00","og_image":[{"width":1350,"height":760,"url":"https:\/\/www.amagicsoft.com\/wp-content\/uploads\/2026\/10\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp","type":"image\/webp"}],"author":"Vasilii","twitter_card":"summary_large_image","twitter_creator":"@Amagicsoft","twitter_site":"@Amagicsoft","twitter_misc":{"\u00c9crit par":"Vasilii","Dur\u00e9e de lecture estim\u00e9e":"14 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html#article","isPartOf":{"@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html"},"author":{"name":"Vasilii","@id":"https:\/\/www.amagicsoft.com\/zh\/#\/schema\/person\/5cc725a7bfa9bc0e962db26a19dfb8c2"},"headline":"GPT Partition Entry: Structure, Array, and GUID Fields","datePublished":"2026-10-29T03:42:14+00:00","mainEntityOfPage":{"@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html"},"wordCount":2800,"publisher":{"@id":"https:\/\/www.amagicsoft.com\/zh\/#organization"},"image":{"@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html#primaryimage"},"thumbnailUrl":"https:\/\/www.amagicsoft.com\/wp-content\/uploads\/2026\/10\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp","keywords":["Knowledge Base"],"articleSection":["Disk &amp; Partition"],"inLanguage":"fr-FR"},{"@type":"WebPage","@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html","url":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html","name":"Entr\u00e9e de partition GPT : champs \u00ab Structure \u00bb, \u00ab Array \u00bb et \u00ab GUID \u00bb | Amagicsoft","isPartOf":{"@id":"https:\/\/www.amagicsoft.com\/zh\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html#primaryimage"},"image":{"@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html#primaryimage"},"thumbnailUrl":"https:\/\/www.amagicsoft.com\/wp-content\/uploads\/2026\/10\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp","datePublished":"2026-10-29T03:42:14+00:00","description":"Comprendre les champs des entr\u00e9es de partition GPT, le codage GUID, les d\u00e9calages des tableaux d'entr\u00e9es, les limites LBA et les contraintes li\u00e9es \u00e0 la validation CRC32.","breadcrumb":{"@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html#primaryimage","url":"https:\/\/www.amagicsoft.com\/wp-content\/uploads\/2026\/10\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp","contentUrl":"https:\/\/www.amagicsoft.com\/wp-content\/uploads\/2026\/10\/GPT-Partition-Entry-Structure-Array-and-GUID-Fields.webp","width":1350,"height":760,"caption":"GPT Partition Entry Structure, Array, and GUID Fields"},{"@type":"BreadcrumbList","@id":"https:\/\/www.amagicsoft.com\/kb\/disk-partition\/gpt-partition-entry.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.amagicsoft.com\/"},{"@type":"ListItem","position":2,"name":"GPT Partition Entry: Structure, Array, and GUID Fields"}]},{"@type":"WebSite","@id":"https:\/\/www.amagicsoft.com\/zh\/#website","url":"https:\/\/www.amagicsoft.com\/zh\/","name":"Amagicsoft","description":"","publisher":{"@id":"https:\/\/www.amagicsoft.com\/zh\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.amagicsoft.com\/zh\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/www.amagicsoft.com\/zh\/#organization","name":"Amagicsoft","url":"https:\/\/www.amagicsoft.com\/zh\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/www.amagicsoft.com\/zh\/#\/schema\/logo\/image\/","url":"https:\/\/www.amagicsoft.com\/wp-content\/uploads\/2025\/04\/cropped-logo_512x512-1.webp","contentUrl":"https:\/\/www.amagicsoft.com\/wp-content\/uploads\/2025\/04\/cropped-logo_512x512-1.webp","width":512,"height":512,"caption":"Amagicsoft"},"image":{"@id":"https:\/\/www.amagicsoft.com\/zh\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/amagicsoft.2024\/","https:\/\/x.com\/Amagicsoft"]},{"@type":"Person","@id":"https:\/\/www.amagicsoft.com\/zh\/#\/schema\/person\/5cc725a7bfa9bc0e962db26a19dfb8c2","name":"Vasilii","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/12fbd3cf5c3fd435565e0ee05fea6fb3ae89413aafdccfb30c0c821c69a44d12?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/12fbd3cf5c3fd435565e0ee05fea6fb3ae89413aafdccfb30c0c821c69a44d12?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/12fbd3cf5c3fd435565e0ee05fea6fb3ae89413aafdccfb30c0c821c69a44d12?s=96&d=mm&r=g","caption":"Vasilii"},"description":"Vasilii est un sp\u00e9cialiste de la r\u00e9cup\u00e9ration de donn\u00e9es qui poss\u00e8de une dizaine d'ann\u00e9es d'exp\u00e9rience pratique dans ce domaine. Tout au long de sa carri\u00e8re, il a r\u00e9solu avec succ\u00e8s des milliers de cas complexes impliquant des fichiers supprim\u00e9s, des disques format\u00e9s, des partitions perdues et des syst\u00e8mes de fichiers RAW. Son expertise couvre \u00e0 la fois les m\u00e9thodes de r\u00e9cup\u00e9ration manuelle \u00e0 l'aide d'outils professionnels tels que les \u00e9diteurs hexagonaux et les solutions automatis\u00e9es avanc\u00e9es \u00e0 l'aide de logiciels de r\u00e9cup\u00e9ration. La mission de Vasilii est de rendre accessible aux professionnels de l'informatique et aux utilisateurs quotidiens des connaissances fiables en mati\u00e8re de r\u00e9cup\u00e9ration de donn\u00e9es, afin de les aider \u00e0 sauvegarder leurs pr\u00e9cieuses ressources num\u00e9riques.","sameAs":["https:\/\/www.linkedin.com\/in\/vasilii-zaitsev-65894b376\/"],"url":"https:\/\/www.amagicsoft.com\/fr\/author\/vasilii"}]}},"_links":{"self":[{"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/posts\/57985","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/comments?post=57985"}],"version-history":[{"count":3,"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/posts\/57985\/revisions"}],"predecessor-version":[{"id":57991,"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/posts\/57985\/revisions\/57991"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/media\/57986"}],"wp:attachment":[{"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/media?parent=57985"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/categories?post=57985"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.amagicsoft.com\/fr\/wp-json\/wp\/v2\/tags?post=57985"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}