ovs-thread: Add new support for thread-specific data.
[sliver-openvswitch.git] / lib / uuid.c
1 /* Copyright (c) 2008, 2009, 2010, 2011, 2013 Nicira, Inc.
2  *
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:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
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.
14  */
15
16 #include <config.h>
17
18 #include "uuid.h"
19
20 #include <ctype.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <sys/time.h>
24 #include <sys/types.h>
25 #include <unistd.h>
26
27 #include "aes128.h"
28 #include "entropy.h"
29 #include "ovs-thread.h"
30 #include "sha1.h"
31 #include "timeval.h"
32 #include "util.h"
33
34 static struct aes128 key;
35 static uint64_t counter[2];
36 BUILD_ASSERT_DECL(sizeof counter == 16);
37
38 static void do_init(void);
39
40 /*
41  * Initialize the UUID module.  Aborts the program with an error message if
42  * initialization fails (which should never happen on a properly configured
43  * machine.)
44  *
45  * Currently initialization is only needed by uuid_generate().  uuid_generate()
46  * will automatically call uuid_init() itself, so it's only necessary to call
47  * this function explicitly if you want to abort the program earlier than the
48  * first UUID generation in case of failure.
49  */
50 void
51 uuid_init(void)
52 {
53     static pthread_once_t once = PTHREAD_ONCE_INIT;
54     pthread_once(&once, do_init);
55 }
56
57 /* Generates a new random UUID in 'uuid'.
58  *
59  * We go to some trouble to ensure as best we can that the generated UUID has
60  * these properties:
61  *
62  *      - Uniqueness.  The random number generator is seeded using both the
63  *        system clock and the system random number generator, plus a few
64  *        other identifiers, which is about as good as we can get in any kind
65  *        of simple way.
66  *
67  *      - Unpredictability.  In some situations it could be bad for an
68  *        adversary to be able to guess the next UUID to be generated with some
69  *        probability of success.  This property may or may not be important
70  *        for our purposes, but it is better if we can get it.
71  *
72  * To ensure both of these, we start by taking our seed data and passing it
73  * through SHA-1.  We use the result as an AES-128 key.  We also generate a
74  * random 16-byte value[*] which we then use as the counter for CTR mode.  To
75  * generate a UUID in a manner compliant with the above goals, we merely
76  * increment the counter and encrypt it.
77  *
78  * [*] It is not actually important that the initial value of the counter be
79  *     random.  AES-128 in counter mode is secure either way.
80  */
81 void
82 uuid_generate(struct uuid *uuid)
83 {
84     static struct ovs_mutex mutex = OVS_MUTEX_INITIALIZER;
85     uint64_t copy[2];
86
87     uuid_init();
88
89     /* Copy out the counter's current value, then increment it. */
90     ovs_mutex_lock(&mutex);
91     copy[0] = counter[0];
92     copy[1] = counter[1];
93     if (++counter[1] == 0) {
94         counter[0]++;
95     }
96     ovs_mutex_unlock(&mutex);
97
98     /* AES output is exactly 16 bytes, so we encrypt directly into 'uuid'. */
99     aes128_encrypt(&key, copy, uuid);
100
101     /* Set bits to indicate a random UUID.  See RFC 4122 section 4.4. */
102     uuid->parts[2] &= ~0xc0000000;
103     uuid->parts[2] |=  0x80000000;
104     uuid->parts[1] &= ~0x0000f000;
105     uuid->parts[1] |=  0x00004000;
106 }
107
108 /* Sets 'uuid' to all-zero-bits. */
109 void
110 uuid_zero(struct uuid *uuid)
111 {
112     uuid->parts[0] = uuid->parts[1] = uuid->parts[2] = uuid->parts[3] = 0;
113 }
114
115 /* Returns true if 'uuid' is all zero, otherwise false. */
116 bool
117 uuid_is_zero(const struct uuid *uuid)
118 {
119     return (!uuid->parts[0] && !uuid->parts[1]
120             && !uuid->parts[2] && !uuid->parts[3]);
121 }
122
123 /* Compares 'a' and 'b'.  Returns a negative value if 'a < b', zero if 'a ==
124  * b', or positive if 'a > b'.  The ordering is lexicographical order of the
125  * conventional way of writing out UUIDs as strings. */
126 int
127 uuid_compare_3way(const struct uuid *a, const struct uuid *b)
128 {
129     if (a->parts[0] != b->parts[0]) {
130         return a->parts[0] > b->parts[0] ? 1 : -1;
131     } else if (a->parts[1] != b->parts[1]) {
132         return a->parts[1] > b->parts[1] ? 1 : -1;
133     } else if (a->parts[2] != b->parts[2]) {
134         return a->parts[2] > b->parts[2] ? 1 : -1;
135     } else if (a->parts[3] != b->parts[3]) {
136         return a->parts[3] > b->parts[3] ? 1 : -1;
137     } else {
138         return 0;
139     }
140 }
141
142 /* Attempts to convert string 's' into a UUID in 'uuid'.  Returns true if
143  * successful, which will be the case only if 's' has the exact format
144  * specified by RFC 4122.  Returns false on failure.  On failure, 'uuid' will
145  * be set to all-zero-bits. */
146 bool
147 uuid_from_string(struct uuid *uuid, const char *s)
148 {
149     if (!uuid_from_string_prefix(uuid, s)) {
150         return false;
151     } else if (s[UUID_LEN] != '\0') {
152         uuid_zero(uuid);
153         return false;
154     } else {
155         return true;
156     }
157 }
158
159 /* Same as uuid_from_string() but s[UUID_LEN] is not required to be a null byte
160  * to succeed; that is, 's' need only begin with UUID syntax, not consist
161  * entirely of it. */
162 bool
163 uuid_from_string_prefix(struct uuid *uuid, const char *s)
164 {
165     /* 0         1         2         3      */
166     /* 012345678901234567890123456789012345 */
167     /* ------------------------------------ */
168     /* 00000000-1111-1111-2222-222233333333 */
169
170     bool ok;
171
172     uuid->parts[0] = hexits_value(s, 8, &ok);
173     if (!ok || s[8] != '-') {
174         goto error;
175     }
176
177     uuid->parts[1] = hexits_value(s + 9, 4, &ok) << 16;
178     if (!ok || s[13] != '-') {
179         goto error;
180     }
181
182     uuid->parts[1] += hexits_value(s + 14, 4, &ok);
183     if (!ok || s[18] != '-') {
184         goto error;
185     }
186
187     uuid->parts[2] = hexits_value(s + 19, 4, &ok) << 16;
188     if (!ok || s[23] != '-') {
189         goto error;
190     }
191
192     uuid->parts[2] += hexits_value(s + 24, 4, &ok);
193     if (!ok) {
194         goto error;
195     }
196
197     uuid->parts[3] = hexits_value(s + 28, 8, &ok);
198     if (!ok) {
199         goto error;
200     }
201     return true;
202
203 error:
204     uuid_zero(uuid);
205     return false;
206 }
207 \f
208 static void
209 do_init(void)
210 {
211     uint8_t sha1[SHA1_DIGEST_SIZE];
212     struct sha1_ctx sha1_ctx;
213     uint8_t random_seed[16];
214     struct timeval now;
215     pid_t pid, ppid;
216     uid_t uid;
217     gid_t gid;
218
219     /* Get seed data. */
220     get_entropy_or_die(random_seed, sizeof random_seed);
221     xgettimeofday(&now);
222     pid = getpid();
223     ppid = getppid();
224     uid = getuid();
225     gid = getgid();
226
227     /* Convert seed into key. */
228     sha1_init(&sha1_ctx);
229     sha1_update(&sha1_ctx, random_seed, sizeof random_seed);
230     sha1_update(&sha1_ctx, &pid, sizeof pid);
231     sha1_update(&sha1_ctx, &ppid, sizeof ppid);
232     sha1_update(&sha1_ctx, &uid, sizeof uid);
233     sha1_update(&sha1_ctx, &gid, sizeof gid);
234     sha1_final(&sha1_ctx, sha1);
235
236     /* Generate key. */
237     BUILD_ASSERT(sizeof sha1 >= 16);
238     aes128_schedule(&key, sha1);
239
240     /* Generate initial counter. */
241     get_entropy_or_die(counter, sizeof counter);
242 }