OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 // | |
5 // Library functions related to the OEM Deal Confirmation Code. | |
6 | |
7 #include "rlz/win/lib/machine_deal.h" | |
8 | |
9 #include <windows.h> | |
10 #include <vector> | |
11 | |
12 #include "base/basictypes.h" | |
13 #include "base/memory/scoped_ptr.h" | |
14 #include "base/string_split.h" | |
15 #include "base/string_util.h" | |
16 #include "base/stringprintf.h" | |
17 #include "base/win/registry.h" | |
18 #include "rlz/lib/assert.h" | |
19 #include "rlz/lib/lib_values.h" | |
20 #include "rlz/win/lib/lib_mutex.h" | |
21 #include "rlz/win/lib/registry_util.h" | |
22 #include "rlz/win/lib/rlz_value_store_registry.h" | |
23 | |
24 const wchar_t kDccValueName[] = L"DCC"; | |
25 | |
26 namespace { | |
27 | |
28 // Current DCC can only uses [a-zA-Z0-9_-!@$*();.<>,:] | |
29 // We will be more liberal and allow some additional chars, but not url meta | |
30 // chars. | |
31 bool IsGoodDccChar(char ch) { | |
32 if (IsAsciiAlpha(ch) || IsAsciiDigit(ch)) | |
33 return true; | |
34 | |
35 switch (ch) { | |
36 case '_': | |
37 case '-': | |
38 case '!': | |
39 case '@': | |
40 case '$': | |
41 case '*': | |
42 case '(': | |
43 case ')': | |
44 case ';': | |
45 case '.': | |
46 case '<': | |
47 case '>': | |
48 case ',': | |
49 case ':': | |
50 return true; | |
51 } | |
52 | |
53 return false; | |
54 } | |
55 | |
56 // This function will remove bad rlz chars and also limit the max rlz to some | |
57 // reasonable size. It also assumes that normalized_dcc is at least | |
58 // kMaxDccLength+1 long. | |
59 void NormalizeDcc(const char* raw_dcc, char* normalized_dcc) { | |
60 int index = 0; | |
61 for (; raw_dcc[index] != 0 && index < rlz_lib::kMaxDccLength; ++index) { | |
62 char current = raw_dcc[index]; | |
63 if (IsGoodDccChar(current)) { | |
64 normalized_dcc[index] = current; | |
65 } else { | |
66 normalized_dcc[index] = '.'; | |
67 } | |
68 } | |
69 | |
70 normalized_dcc[index] = 0; | |
71 } | |
72 | |
73 bool GetResponseLine(const char* response_text, int response_length, | |
74 int* search_index, std::string* response_line) { | |
75 if (!response_line || !search_index || *search_index > response_length) | |
76 return false; | |
77 | |
78 response_line->clear(); | |
79 | |
80 if (*search_index < 0) | |
81 return false; | |
82 | |
83 int line_begin = *search_index; | |
84 const char* line_end = strchr(response_text + line_begin, '\n'); | |
85 | |
86 if (line_end == NULL || line_end - response_text > response_length) { | |
87 line_end = response_text + response_length; | |
88 *search_index = -1; | |
89 } else { | |
90 *search_index = line_end - response_text + 1; | |
91 } | |
92 | |
93 response_line->assign(response_text + line_begin, | |
94 line_end - response_text - line_begin); | |
95 return true; | |
96 } | |
97 | |
98 bool GetResponseValue(const std::string& response_line, | |
99 const std::string& response_key, | |
100 std::string* value) { | |
101 if (!value) | |
102 return false; | |
103 | |
104 value->clear(); | |
105 | |
106 if (!StartsWithASCII(response_line, response_key, true)) | |
107 return false; | |
108 | |
109 std::vector<std::string> tokens; | |
110 base::SplitString(response_line, ':', &tokens); | |
111 if (tokens.size() != 2) | |
112 return false; | |
113 | |
114 // The first token is the key, the second is the value. The value is already | |
115 // trimmed for whitespace. | |
116 *value = tokens[1]; | |
117 return true; | |
118 } | |
119 | |
120 } // namespace anonymous | |
121 | |
122 namespace rlz_lib { | |
123 | |
124 bool MachineDealCode::Set(const char* dcc) { | |
125 LibMutex lock; | |
126 if (lock.failed()) | |
127 return false; | |
128 | |
129 // TODO: if (!ProcessInfo::CanWriteMachineKey()) return false; | |
130 | |
131 // Validate the new dcc value. | |
132 size_t length = strlen(dcc); | |
133 if (length > kMaxDccLength) { | |
134 ASSERT_STRING("MachineDealCode::Set: DCC length is exceeds max allowed."); | |
135 return false; | |
136 } | |
137 | |
138 base::win::RegKey hklm_key(HKEY_LOCAL_MACHINE, | |
139 RlzValueStoreRegistry::GetWideLibKeyName().c_str(), | |
140 KEY_READ | KEY_WRITE | KEY_WOW64_32KEY); | |
141 if (!hklm_key.Valid()) { | |
142 ASSERT_STRING("MachineDealCode::Set: Unable to create / open machine key." | |
143 " Did you call rlz_lib::CreateMachineState()?"); | |
144 return false; | |
145 } | |
146 | |
147 char normalized_dcc[kMaxDccLength + 1]; | |
148 NormalizeDcc(dcc, normalized_dcc); | |
149 VERIFY(length == strlen(normalized_dcc)); | |
150 | |
151 // Write the DCC to HKLM. Note that we need to include the null character | |
152 // when writing the string. | |
153 if (!RegKeyWriteValue(hklm_key, kDccValueName, normalized_dcc)) { | |
154 ASSERT_STRING("MachineDealCode::Set: Could not write the DCC value"); | |
155 return false; | |
156 } | |
157 | |
158 return true; | |
159 } | |
160 | |
161 bool MachineDealCode::GetNewCodeFromPingResponse(const char* response, | |
162 bool* has_new_dcc, char* new_dcc, int new_dcc_size) { | |
163 if (!has_new_dcc || !new_dcc || !new_dcc_size) | |
164 return false; | |
165 | |
166 *has_new_dcc = false; | |
167 new_dcc[0] = 0; | |
168 | |
169 int response_length = -1; | |
170 if (!IsPingResponseValid(response, &response_length)) | |
171 return false; | |
172 | |
173 // Get the current DCC value to compare to later) | |
174 char stored_dcc[kMaxDccLength + 1]; | |
175 if (!Get(stored_dcc, arraysize(stored_dcc))) | |
176 stored_dcc[0] = 0; | |
177 | |
178 int search_index = 0; | |
179 std::string response_line; | |
180 std::string new_dcc_value; | |
181 bool old_dcc_confirmed = false; | |
182 const std::string dcc_cgi(kDccCgiVariable); | |
183 const std::string dcc_cgi_response(kSetDccResponseVariable); | |
184 while (GetResponseLine(response, response_length, &search_index, | |
185 &response_line)) { | |
186 std::string value; | |
187 | |
188 if (!old_dcc_confirmed && | |
189 GetResponseValue(response_line, dcc_cgi, &value)) { | |
190 // This is the old DCC confirmation - should match value in registry. | |
191 if (value != stored_dcc) | |
192 return false; // Corrupted DCC - ignore this response. | |
193 else | |
194 old_dcc_confirmed = true; | |
195 continue; | |
196 } | |
197 | |
198 if (!(*has_new_dcc) && | |
199 GetResponseValue(response_line, dcc_cgi_response, &value)) { | |
200 // This is the new DCC. | |
201 if (value.size() > kMaxDccLength) continue; // Too long | |
202 *has_new_dcc = true; | |
203 new_dcc_value = value; | |
204 } | |
205 } | |
206 | |
207 old_dcc_confirmed |= (NULL == stored_dcc[0]); | |
208 | |
209 base::strlcpy(new_dcc, new_dcc_value.c_str(), new_dcc_size); | |
210 return old_dcc_confirmed; | |
211 } | |
212 | |
213 bool MachineDealCode::SetFromPingResponse(const char* response) { | |
214 bool has_new_dcc = false; | |
215 char new_dcc[kMaxDccLength + 1]; | |
216 | |
217 bool response_valid = GetNewCodeFromPingResponse( | |
218 response, &has_new_dcc, new_dcc, arraysize(new_dcc)); | |
219 | |
220 if (response_valid && has_new_dcc) | |
221 return Set(new_dcc); | |
222 | |
223 return response_valid; | |
224 } | |
225 | |
226 bool MachineDealCode::GetAsCgi(char* cgi, int cgi_size) { | |
227 if (!cgi || cgi_size <= 0) { | |
228 ASSERT_STRING("MachineDealCode::GetAsCgi: Invalid buffer"); | |
229 return false; | |
230 } | |
231 | |
232 cgi[0] = 0; | |
233 | |
234 std::string cgi_arg; | |
235 base::StringAppendF(&cgi_arg, "%s=", kDccCgiVariable); | |
236 int cgi_arg_length = cgi_arg.size(); | |
237 | |
238 if (cgi_arg_length >= cgi_size) { | |
239 ASSERT_STRING("MachineDealCode::GetAsCgi: Insufficient buffer size"); | |
240 return false; | |
241 } | |
242 | |
243 base::strlcpy(cgi, cgi_arg.c_str(), cgi_size); | |
244 | |
245 if (!Get(cgi + cgi_arg_length, cgi_size - cgi_arg_length)) { | |
246 cgi[0] = 0; | |
247 return false; | |
248 } | |
249 return true; | |
250 } | |
251 | |
252 bool MachineDealCode::Get(char* dcc, int dcc_size) { | |
253 LibMutex lock; | |
254 if (lock.failed()) | |
255 return false; | |
256 | |
257 if (!dcc || dcc_size <= 0) { | |
258 ASSERT_STRING("MachineDealCode::Get: Invalid buffer"); | |
259 return false; | |
260 } | |
261 | |
262 dcc[0] = 0; | |
263 | |
264 base::win::RegKey dcc_key(HKEY_LOCAL_MACHINE, | |
265 RlzValueStoreRegistry::GetWideLibKeyName().c_str(), | |
266 KEY_READ | KEY_WOW64_32KEY); | |
267 if (!dcc_key.Valid()) | |
268 return false; // no DCC key. | |
269 | |
270 size_t size = dcc_size; | |
271 if (!RegKeyReadValue(dcc_key, kDccValueName, dcc, &size)) { | |
272 ASSERT_STRING("MachineDealCode::Get: Insufficient buffer size"); | |
273 dcc[0] = 0; | |
274 return false; | |
275 } | |
276 | |
277 return true; | |
278 } | |
279 | |
280 bool MachineDealCode::Clear() { | |
281 base::win::RegKey dcc_key(HKEY_LOCAL_MACHINE, | |
282 RlzValueStoreRegistry::GetWideLibKeyName().c_str(), | |
283 KEY_READ | KEY_WRITE | KEY_WOW64_32KEY); | |
284 if (!dcc_key.Valid()) | |
285 return false; // no DCC key. | |
286 | |
287 dcc_key.DeleteValue(kDccValueName); | |
288 | |
289 // Verify deletion. | |
290 wchar_t dcc[kMaxDccLength + 1]; | |
291 DWORD dcc_size = arraysize(dcc); | |
292 if (dcc_key.ReadValue(kDccValueName, dcc, &dcc_size, NULL) == ERROR_SUCCESS) { | |
293 ASSERT_STRING("MachineDealCode::Clear: Could not delete the DCC value."); | |
294 return false; | |
295 } | |
296 | |
297 return true; | |
298 } | |
299 | |
300 } // namespace rlz_lib | |
OLD | NEW |