Webreflinks - Globally unique identifier

Most tools require the use of JavaScript. If you are using Firefox with the NoScript addon, please mark toolserver.org as trusted. See the Help page for details.

Documentation Feedback / Report a bug

Introduction by SmartSE

Reflinks will help you to turn bare urls into templated references, hopefully leaving you more time to write and reducing link rot caused by bare urls. The tool visits each webpage that is in a bare reference and collects the page title and some other information automatically, the tool has to be checked over manually to make sure that the references are filled in correctly by the tool. You may have to remove some extra information from the template and add extra details if the tool is not able to find it for you. Some links may be marked as dead links incorrectly as the site blocks the tool, you may wish to manually check these dead links before adding the dead link tag to the article. The tool also does a few other minor maintenance tasks.

Applying English Wikipedia commonfixes
DEPRECATED TAG : <tt> (11) is removed in the HTML 5 specification
No changes necessary: references template found.

WebCite www.ietf.org/rfc/rfc4122.txt

List citation templatesReference on line 14:

	Current revision			Your text
	13	==Binary encoding==		13	==Binary encoding==
t	14	A GUID can be stored as a 16-[[byte]] (128-bit) number; Microsoft defines a format which is split into four fields,<ref name="MSDNGUIDtype"/> defined as follows. Note that this format differs from the [[Universally unique identifier\|UUID]] standard <ref name="rfc4122">[http://www.ietf.org/rfc/rfc4122.txt A Universally Unique IDentifier (UUID) URN Namespace]</ref> only in the byte order of the first 3 fields.	t	14	A GUID can be stored as a 16-[[byte]] (128-bit) number; Microsoft defines a format which is split into four fields,<ref name="MSDNGUIDtype"/> defined as follows. Note that this format differs from the [[Universally unique identifier\|UUID]] standard <ref name="rfc4122">{{cite web\|url=http://www.ietf.org/rfc/rfc4122.txt \|title=A Universally Unique IDentifier (UUID) URN Namespace \|date= \|accessdate=2013-06-19}}</ref> only in the byte order of the first 3 fields.
	15			15

A '''Globally Unique Identifier''' ('''GUID''', {{IPAc-en|ˈ|ɡ|w|ɪ|d}} or {{IPAc-en|ˈ|ɡ|uː|ɪ|d}}) is a unique reference number used as an identifier in [[computer software]]. The term '''GUID''' typically refers to various implementations of the [[universally unique identifier]] (UUID) standard.<ref name="MSDNGUIDtype">{{cite web|url=http://msdn.microsoft.com/en-us/library/aa373931(VS.85).aspx |title=GUID structure (Windows) |publisher=Msdn.microsoft.com |date= |accessdate=2012-08-14}}</ref>

GUIDs are usually stored as 128-bit values, and are commonly displayed as 32 [[hexadecimal]] digits with groups separated by hyphens, such as <tt>{21EC2020-3AEA-1069-A2DD-08002B30309D}</tt>.  GUIDs generated from random numbers contain 6 fixed bits saying they are random and 122 random bits; the total number of unique such GUIDs is 2<sup>122</sup> or 5.3×10<sup>36</sup>.  This number is so large that the probability of the same number being generated randomly twice is negligible; however other GUID versions have different uniqueness properties and probabilities, ranging from guaranteed uniqueness to likely non-uniqueness.

==Common uses==
* [[Microsoft Windows]] uses GUIDs internally to identify the classes and interfaces of [[Component Object Model|COM]] objects. A script can activate a specific class or object without having to know the name or location of the [[Library (computing)#Dynamic linking|dynamic linked library]] that contains it.
* [[ActiveX]], a system for downloading and installing controls in a web browser, uses GUIDs to uniquely identify each control.
* [[Intel]]'s [[GUID Partition Table|GUID Partition Table, or GPT]], a system for [[Disk partitioning|partitioning]] hard drives.
* [[JT (visualization format)|JT files]] use a partitioning into 4+2+2+8*1 bytes to represent nodes in the data structure and segment ID's.
* [[Second Life]] uses GUIDs for identification of all assets in its world.
* Database developers and administrators often use GUIDs as primary keys for database tables to ensure uniqueness between databases.

==Binary encoding==
A GUID can be stored as a 16-[[byte]] (128-bit) number; Microsoft defines a format which is split into four fields,<ref name="MSDNGUIDtype"/>  defined as follows. Note that this format differs from the [[Universally unique identifier|UUID]] standard <ref name="rfc4122">{{cite web|url=http://www.ietf.org/rfc/rfc4122.txt |title=A Universally Unique IDentifier (UUID) URN Namespace |date= |accessdate=2013-06-19}}</ref> only in the byte order of the first 3 fields.

{| class="wikitable"
|-
!Bits
!Bytes
!Name
![[Endianness]]
(Microsoft GUID Structure)
![[Endianness]]
RFC 4122
|-
|32||4||Data1||Native||Big
|-
|16||2||Data2||Native||Big
|-
|16||2||Data3||Native||Big
|-
|64||8||Data4||Big||Big
|}
This endianness applies only to the way in which a GUID is stored, and not to the way in which it is represented in text.
GUIDs and RFC 4122 UUIDs should be identical when displayed textually.

One to three of the most significant bits of the first byte in Data 4 define the type variant of the GUID:<ref name="rfc4122"/>

{| class="wikitable"
|-
!Pattern!!Description
|-
|0xx||[[Network Computing System]] backward compatibility
|-
|10x||Standard
|-
|110||Microsoft [[Component Object Model]] backward compatibility; this includes the GUIDs for important interfaces like [[IUnknown]] and [[IDispatch]]
|-
|111||Reserved for future use
|}
For the "standard" variant, the most significant four bits of Data3 define the version number, and the algorithm used.<ref name="rfc4122"/>

==Text encoding==
A GUID is most commonly written in text as a sequence of [[hexadecimal]] digits separated into five groups, such as:
:<tt>3F2504E0-4F89-11D3-9A0C-0305E82C3301</tt>

This text notation contains the following fields, separated by hyphens:
{| class="wikitable"
|-
!Hex digits!!Description
|-
|8||Data1
|-
|4||Data2
|-
|4||Data3
|-
|4||Initial two bytes from Data4
|-
|12||Remaining six bytes from Data4
|}
For the first three fields, the most significant digit is on the left. The last two fields are treated as eight separate bytes, each having their most significant digit on the left, and they follow each other from left to right. Note that the digit order of the fourth field may be unexpected, since it's treated differently than in the structure.

Often braces are added to enclose the above format, such as:
:<tt>{3F2504E0-4F89-11D3-9A0C-0305E82C3301}</tt>
This is sometimes known as "registry format".<ref>[http://msdn.microsoft.com/en-us/library/windows/desktop/dd564255%28v=vs.85%29.aspx Registry Keys and Entries for a Type 1 Online Store]. Microsoft.com.</ref>

When printing fewer characters is desired, GUIDs are sometimes encoded into a [[base64]] or [[Ascii85]] string.{{citation needed|date=July 2012}}

A base64-encoded GUID consists of 22 to 24 characters (depending on padding), for instance:

:<code>4AQlP4lP0xGaDAMF6CwzAQ</code>
:<code>4AQlP4lP0xGaDAMF6CwzAQ==</code>

and [[Ascii85]] encoding gives 20 characters, for example:

:<code>5:$Hj:Pf\4RLB9%kU\Lj</code>

In [[Uniform Resource Name]]s (URN), GUIDs have namespace identifier "uuid",<ref name="rfc4122" /> e.g.:

:<code>urn:uuid:3F2504E0-4F89-11D3-9A0C-0305E82C3301</code>

==Algorithm==
In the [[Open Software Foundation|OSF]]-specified [[algorithm]] for generating new (V1) GUIDs, the user's [[network card]] [[MAC address]] is used as a base for the last group of GUID digits, which means, for example, that a document can be tracked back to the computer that created it. This [[privacy]] hole was used when locating the creator of the [[Melissa (computer virus)|Melissa virus]].<ref name="colloaboration">{{cite press release
| title = Tracking Melissa's alter egos
| publisher = ZDNet
| date = 1999-04-02
| url = http://www.zdnet.com/news/tracking-melissas-alter-egos/101974
}}</ref> Most of the other digits are based on the time while generating the GUID.

V1 GUIDs which contain a MAC address and time can be identified by the digit "1" in the first position of the third group of digits, for example <tt>{2F1E4FC0-81FD-'''''1'''''1DA-9156-00036A0F876A}</tt>.

V4 GUIDs use the later algorithm, which is a [[pseudo-random]] number. These have a "4" in the same position, for example <tt>{38A52BE4-9352-'''''4'''''53E-AF97-5C3B448652F0}</tt>. More specifically, the 'data3' bit pattern would be <code>0001xxxxxxxxxxxx</code> in the first case, and <code>0100xxxxxxxxxxxx</code> in the second. [[Cryptanalysis]] of the [[WinAPI]] GUID generator shows that, since the sequence of V4 GUIDs is pseudo-random, given full knowledge of the internal state, it is possible to predict previous and subsequent values.<ref>{{cite web|url=http://www.gotdotnet.ru/blogs/denish/1965/ |title=Design and Cryptanalysis of UUID-generator in Windows |publisher=Gotdotnet.ru |date=2008-06-23 |accessdate=2012-06-20}}</ref>

==Non-unique GUIDs==
Certain GUIDs turn up again and again, both intentionally, and otherwise.  In a [[GUID Partition Table]] (GPT), it's not appropriate for more than one disk to have the same ''Disk GUID'', or for more than one partition to have the same ''Unique partition GUID'', however it is appropriate for multiple partitions to use the same ''Partition type GUID''.  So only Linux swap partitions, and all Linux swap partitions on GPT-formatted disks can be counted on to have the GUID <tt>0657FD6D-A4AB-43C4-84E5-0933C84B4F4F</tt>, for example.

Some flawed GUID-generating implementations rely on pseudo-random number generators that use random number seed sources that turn out to be predictable.  Standard Valid GUIDs are not chosen at random; they are chosen by standardized algorithms. (See, e.g. RFC 4122.) These algorithms result in GUIDs that are more reliably unique than ones chosen using even a hypothetically perfect random number generator, and far more reliably unique than numbers chosen by pseudorandom number generators.

=== Non-unique FireWire GUIDs===
Operating systems (including Windows, Mac OS X and Linux) are designed based on the expectation that a given disk will never have the same ''Disk GUID'' as another.  However, the so-called FireWire GUIDs (which are called GUIDs, but are a non-standard 64 bits) of every unit of several common models of hard drive/drive case that each use the same manufacturer's chipset, Oxford Semiconductor, all have the same GUID - <tt>0x30E002E0454647</tt> (sometimes displayed in decimal form as Connection ID <tt>13757101839304263</tt>) including NewerTech, Vantec, and Cavalry, and this causes problems when such drives are daisy-chained or otherwise connected to the same system. The manufacturers were supposed to serialize them, but many didn't.{{clarify|pre-text=when?|date=November 2012}}<ref>{{cite web|url=http://www.lecentre.net/blog/archives/171#respond |title=Using two usb/firewire external drive with oxford chip « Prune's Blog |publisher=Lecentre.net |date= |accessdate=2013-04-06}}</ref>

==Sequential algorithms==
GUIDs are commonly used as the [[primary key]] of database tables, and with that, often the table has a [[clustered index]] on that attribute. This presents a performance issue when inserting records because a fully random GUID means the record may need to be inserted anywhere within the table rather than merely appended near the end of it.

As a way of mitigating this issue while still providing enough randomness to effectively prevent duplicate number collisions, several algorithms have been used to generate sequential GUIDs.

The oldest technique, present as a feature in early version of Microsoft's GUIDGEN SDK tool, works by simply outputting the set of MAC-based version 1 GUIDs corresponding to a time interval, taking advantage of the fact that the time field in v1 GUIDs has a resolution of 100&nbsp;ns, which allows a million sequential GUIDs to be generated by simply locking out other GUID generators on the computer for a tenth of a second (or 10000 GUIDs in a millisecond).  These sequential GUIDs are unique, but the increment happens in the Data1 field, not at the end of the GUID.

The second technique, described by Jimmy Nilsson in August 2002<ref>{{cite web|last=Nilsson |first=Jimmy |url=http://www.informit.com/articles/article.aspx?p=25862 |title=InformIT |publisher=InformIT |date= |accessdate=2012-06-20}}</ref> and referred to as a "COMB" ("combined guid/timestamp"), replaces the last 6 bytes of Data4 in a random (version 4) GUID with the least-significant 6 bytes of the current system date/time. While this can result in GUIDs that are generated out of order within the same fraction of a second, his tests showed this had little {{cl-span|[[real-world]]|date=November 2012}} impact on insertion. One side effect of this approach is that the date and time of insertion can be easily extracted from the value later, if desired.  The COMB technique tries to compensate for the reduced clustering in database indexes caused by switching to an OS version that uses random GUIDs rather than MAC-based GUIDs, and is useful only when it is not possible to revert to version 1 GUIDs.

Starting with [[Microsoft SQL Server]] version 2005, [[Microsoft]] added a function to the [[Transact-SQL]] language called NEWSEQUENTIALID(),<ref>{{cite web|url=http://msdn.microsoft.com/en-us/library/ms189786.aspx |title=MSDN |publisher=Msdn.microsoft.com |date= |accessdate=2012-06-20}}</ref> which essentially provides access to the traditional version 1 GUIDs (or something so close it fits the same description), with all their advantages and disadvantages.

In 2006, a programmer found that the SYS_GUID function provided by Oracle was returning sequential GUIDs on some platforms, but this appears to be a bug rather than a feature.<ref>[http://feuerthoughts.blogspot.com/2006/02/watch-out-for-sequential-oracle-guids.html Watch out for sequential Oracle GUIDs!], Steven Feuerstein, ''Oracle Professional'', 19 February 2006. Retrieved 2011-12-08.</ref>

==Uses==
In the Microsoft [[Component Object Model]] (COM), GUIDs are used to uniquely distinguish different [[software componentry|software component]] interfaces. This means that two (possibly incompatible) versions of a component can have exactly the same name but still be distinguishable by their GUIDs. For example, in the creation of components for Microsoft Windows using COM, all components must implement the [[IUnknown]] interface to allow client code to find all other [[interface (computer science)|interfaces]] and features of that component, and they do this by creating a GUID which may be called upon to provide an entry point.  The <code>IUnknown</code> interface is defined as a GUID with the value of <tt>{00000000-0000-0000-C000-000000000046}</tt>, and rather than having a named entry point called "IUnknown", the preceding GUID is used, thus every component that provides an IUnknown entry point gives the same GUID, and every program that looks for an IUnknown interface in a component always uses that GUID to find the entry point, knowing that an application using that particular GUID must always consistently implement IUnknown in the same manner and the same way.

GUIDs are also inserted into documents from [[Microsoft Office]] programs. Even audio or video streams in the [[Advanced Systems Format]] (ASF) are identified by their GUIDs.

A GUID's representation can be [[little endian]] or [[big endian]], so all APIs need to ensure that the correct data structure is used.

==Subtypes==
There are several flavors of GUIDs used in COM:

* IID – interface identifier; (The ones that are registered on a system are stored in the Windows Registry at the key HKEY_CLASSES_ROOT\Interface)
* CLSID – class identifier; (Stored in the registry at HKEY_CLASSES_ROOT\CLSID)
* LIBID – type library identifier;
* CATID – category identifier; (its presence on a class identifies it as belonging to certain class categories)

[[Distributed Component Object Model|DCOM]] introduces many additional GUID subtypes:
* AppID – application identifier;
* MID – machine identifier;
* IPID – interface pointer identifier; (applicable to an interface engaged in RPC)
* CID – causality identifier; (applicable to a RPC session)
* OID – object identifier; (applicable to an object instance)
* OXID – object exporter identifier; (applicable to an instance of the system object that performs RPC)
* SETID – ping set identifier; (applicable to a group of objects)

These GUID subspaces may overlap, as the context of GUID usage defines its subtype. For example, there might be a class using the same GUID for its CLSID as another class is using for its IID — all without a problem. On the other hand, two classes using the same CLSID could not co-exist.

==XML syndication formats==
There is also a <tt>guid</tt> element in some versions of the [[RSS (file format)|RSS]] specification, and a mandatory <tt>id</tt> element in [[Atom (standard)|Atom]], which should contain a unique identifier for each individual article or weblog post. In RSS the contents of the GUID can be any text, and in practice is typically a copy of the article [[Uniform Resource Locator|URL]]. Atoms' IDs need to be valid [[Uniform Resource Identifier|URI]]s (usually [[Uniform Resource Locator|URL]]s pointing to the entry, or [[Uniform Resource Name|URN]]s containing any other unique identifier).

==See also==
* [[Security Identifier]] (SID)
* [[Object identifier]] (OID)
* [[Device fingerprint]]

==References==
{{Reflist}}
{{Refbegin}}
* [http://www.ietf.org/rfc/rfc4122.txt A Universally Unique IDentifier (UUID) URN Namespace (IETF RFC 4122)]
* [http://msdn2.microsoft.com/en-us/library/cc246027.aspx Globally Unique Identifiers - Internal Structure (Microsoft)]
{{Refend}}

==External links==

* [https://developer.apple.com/library/mac/#technotes/tn2166/_index.html#//apple_ref/doc/uid/DTS10003927  Technical Note TN2166 Secrets of the GPT]
* [http://msdn.microsoft.com/en-us/windows/hardware/gg463149  UEFI and Windows]
* [http://msdn.microsoft.com/en-us/library/ms691424(VS.85).aspx CLSID Registry Key Information]
* [http://www.itu.int/ITU-T/studygroups/com17/oid.html International Standard "Generation and registration of Universally Unique Identifiers (UUIDs) and their use as ASN.1 Object Identifier components"] (ITU-T Rec. X.667 | ISO/IEC 9834-8, technically compatible with IETF RFC 4122)
* [http://www.infonuovo.com/dma/csdocs/sketch/instidid.htm DmaId for InstanceId Values (DCE Universally Unique IDentifiers, UUIDs)]
* [http://www.opengroup.org/onlinepubs/9629399/apdxa.htm Syntax and semantics of the DCE variant of Universal Unique Identifiers (UUIDs)]
* [http://java.sun.com/j2se/1.5.0/docs/api/java/util/UUID.html Generate and parse UUIDs (or GUIDs) in Java]
* [http://www.itu.int/ITU-T/asn1/uuid.html UUID Generator on the ITU-T website]
* [http://GUID.us GUID Generator and source code samples to make GUIDs/UUIDs]
* [http://gg.codeplex.com/ WPF Guid Generator - GUID Generator for Windows (with source code)]
* [http://tembolab.pl/products/uuid-factory.html UUID Factory - freeware program for Windows]

{{DEFAULTSORT:Globally Unique Identifier}}
[[Category:Windows administration]]
[[Category:Identifiers]]
[[Category:Universal identifiers]]

Edit summary:
This is a minor edit Watch this page

Cancel

Webreflinks - Globally unique identifier

Tools

Interaction