]>
git.proxmox.com Git - mirror_ovs.git/blob - lib/uuid.c
1 /* Copyright (c) 2008, 2009, 2010 Nicira Networks
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
24 #include <sys/types.h>
31 static struct aes128 key
;
32 static uint64_t counter
[2];
33 BUILD_ASSERT_DECL(sizeof counter
== 16);
35 static void do_init(void);
36 static void read_urandom(void *buffer
, size_t n
);
39 * Initialize the UUID module. Aborts the program with an error message if
40 * initialization fails (which should never happen on a properly configured
43 * Currently initialization is only needed by uuid_generate(). uuid_generate()
44 * will automatically call uuid_init() itself, so it's only necessary to call
45 * this function explicitly if you want to abort the program earlier than the
46 * first UUID generation in case of failure.
58 /* Generates a new random UUID in 'uuid'.
60 * We go to some trouble to ensure as best we can that the generated UUID has
63 * - Uniqueness. The random number generator is seeded using both the
64 * system clock and the system random number generator, plus a few
65 * other identifiers, which is about as good as we can get in any kind
68 * - Unpredictability. In some situations it could be bad for an
69 * adversary to be able to guess the next UUID to be generated with some
70 * probability of success. This property may or may not be important
71 * for our purposes, but it is better if we can get it.
73 * To ensure both of these, we start by taking our seed data and passing it
74 * through SHA-1. We use the result as an AES-128 key. We also generate a
75 * random 16-byte value[*] which we then use as the counter for CTR mode. To
76 * generate a UUID in a manner compliant with the above goals, we merely
77 * increment the counter and encrypt it.
79 * [*] It is not actually important that the initial value of the counter be
80 * random. AES-128 in counter mode is secure either way.
83 uuid_generate(struct uuid
*uuid
)
87 /* Increment the counter. */
88 if (++counter
[1] == 0) {
92 /* AES output is exactly 16 bytes, so we encrypt directly into 'uuid'. */
93 aes128_encrypt(&key
, counter
, uuid
);
95 /* Set bits to indicate a random UUID. See RFC 4122 section 4.4. */
96 uuid
->parts
[2] &= ~0xc0000000;
97 uuid
->parts
[2] |= 0x80000000;
98 uuid
->parts
[1] &= ~0x0000f000;
99 uuid
->parts
[1] |= 0x00004000;
102 /* Sets 'uuid' to all-zero-bits. */
104 uuid_zero(struct uuid
*uuid
)
106 uuid
->parts
[0] = uuid
->parts
[1] = uuid
->parts
[2] = uuid
->parts
[3] = 0;
109 /* Returns true if 'uuid' is all zero, otherwise false. */
111 uuid_is_zero(const struct uuid
*uuid
)
113 return (!uuid
->parts
[0] && !uuid
->parts
[1]
114 && !uuid
->parts
[2] && !uuid
->parts
[3]);
117 /* Compares 'a' and 'b'. Returns a negative value if 'a < b', zero if 'a ==
118 * b', or positive if 'a > b'. The ordering is lexicographical order of the
119 * conventional way of writing out UUIDs as strings. */
121 uuid_compare_3way(const struct uuid
*a
, const struct uuid
*b
)
123 if (a
->parts
[0] != b
->parts
[0]) {
124 return a
->parts
[0] > b
->parts
[0] ? 1 : -1;
125 } else if (a
->parts
[1] != b
->parts
[1]) {
126 return a
->parts
[1] > b
->parts
[1] ? 1 : -1;
127 } else if (a
->parts
[2] != b
->parts
[2]) {
128 return a
->parts
[2] > b
->parts
[2] ? 1 : -1;
129 } else if (a
->parts
[3] != b
->parts
[3]) {
130 return a
->parts
[3] > b
->parts
[3] ? 1 : -1;
136 /* Attempts to convert string 's' into a UUID in 'uuid'. Returns true if
137 * successful, which will be the case only if 's' has the exact format
138 * specified by RFC 4122. Returns false on failure. On failure, 'uuid' will
139 * be set to all-zero-bits. */
141 uuid_from_string(struct uuid
*uuid
, const char *s
)
143 if (!uuid_from_string_prefix(uuid
, s
)) {
145 } else if (s
[UUID_LEN
] != '\0') {
153 /* Same as uuid_from_string() but s[UUID_LEN] is not required to be a null byte
154 * to succeed; that is, 's' need only begin with UUID syntax, not consist
157 uuid_from_string_prefix(struct uuid
*uuid
, const char *s
)
159 static const char template[] = "00000000-1111-1111-2222-222233333333";
163 for (t
= template; ; t
++, s
++) {
164 if (*t
>= '0' && *t
<= '3') {
165 uint32_t *part
= &uuid
->parts
[*t
- '0'];
169 *part
= (*part
<< 4) + hexit_value(*s
);
170 } else if (*t
== 0) {
172 } else if (*t
!= *s
) {
185 uint8_t sha1
[SHA1_DIGEST_SIZE
];
186 struct sha1_ctx sha1_ctx
;
187 uint8_t random_seed
[16];
194 get_entropy_or_die(random_seed
, sizeof random_seed
);
195 if (gettimeofday(&now
, NULL
)) {
196 ovs_fatal(errno
, "gettimeofday failed");
203 /* Convert seed into key. */
204 sha1_init(&sha1_ctx
);
205 sha1_update(&sha1_ctx
, random_seed
, sizeof random_seed
);
206 sha1_update(&sha1_ctx
, &pid
, sizeof pid
);
207 sha1_update(&sha1_ctx
, &ppid
, sizeof ppid
);
208 sha1_update(&sha1_ctx
, &uid
, sizeof uid
);
209 sha1_update(&sha1_ctx
, &gid
, sizeof gid
);
210 sha1_final(&sha1_ctx
, sha1
);
213 BUILD_ASSERT(sizeof sha1
>= 16);
214 aes128_schedule(&key
, sha1
);
216 /* Generate initial counter. */
217 get_entropy_or_die(counter
, sizeof counter
);