?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
modified: myjupyterlab.sh
[GalaxyCodeBases.git] / etc / Windows / vlmcsd_old_vancepym / vlmcs.c
blobdb6a60fd1af2f117a92384dc43d8a891e3524ebb
1 #ifndef CONFIG
2 #define CONFIG "config.h"
3 #endif // CONFIG
4 #include CONFIG
5
6 #ifndef _GNU_SOURCE
7 #define _GNU_SOURCE
8 #endif
9
10 #include "vlmcs.h"
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <errno.h>
15 #include <stdint.h>
16 #include <getopt.h>
17 #include <sys/types.h>
18 #include <sys/stat.h>
19 #include <unistd.h>
20 #ifndef _WIN32
21 #include <sys/ioctl.h>
22 #include <termios.h>
23 #else // _WIN32
24 #endif // _WIN32
25 #include "endian.h"
26 #include "shared_globals.h"
27 #include "output.h"
28 #ifndef USE_MSRPC
29 #include "network.h"
30 #include "rpc.h"
31 #else // USE_MSRPC
32 #include "msrpc-client.h"
33 #endif // USE_MSRPC
34 #include "kms.h"
35 #include "helpers.h"
36 #include "dns_srv.h"
37
38
39 #define VLMCS_OPTION_GRAB_INI 1
40 #define VLMCS_OPTION_NO_GRAB_INI 2
41
42 #define kmsVersionMinor 0 // Currently constant. May change in future KMS versions
43
44 // Function Prototypes
45 static void CreateRequestBase(REQUEST *Request);
46
47
48 // KMS Parameters
49 static int_fast8_t verbose = FALSE;
50 static int_fast8_t VMInfo = FALSE;
51 static int_fast8_t dnsnames = TRUE;
52 static int FixedRequests = 0;
53 static BYTE LicenseStatus = 0x02;
54 static const char *CMID = NULL;
55 static const char *CMID_prev = NULL;
56 static const char *WorkstationName = NULL;
57 static int BindingExpiration = 43200; //30 days
58 static const char *RemoteAddr;
59 static int_fast8_t ReconnectForEachRequest = FALSE;
60 static int AddressFamily = AF_UNSPEC;
61 static int_fast8_t incompatibleOptions = 0;
62 static const char* fn_ini_client = NULL;
63
64 #ifndef NO_DNS
65 static int_fast8_t NoSrvRecordPriority = FALSE;
66 #endif // NO_DNS
67
68
69 // Structure for handling "License Packs" (e.g. Office2013v5 or WindowsVista)
70 typedef struct
71 {
72 const char *names; //This is a list of strings. Terminate with additional Zero!!!
73 int N_Policy;
74 int kmsVersionMajor;
75 const GUID *AppID;
76 GUID ActID;
77 GUID KMSID;
78 } LicensePack;
79
80
81 typedef char iniFileEpidLines[3][256];
82
83 // Well known "license packs"
84 static const LicensePack LicensePackList[] =
85 {
86 // List of names min lics version appID skuId KMSCountedID
87 /* 000 */ { "Vista\000W6\000"
88 "WindowsVista\000"
89 "Windows\000", 25, 4, PWINGUID, { 0x4f3d1606, 0x3fea, 0x4c01, { 0xbe, 0x3c, 0x8d, 0x67, 0x1c, 0x40, 0x1e, 0x3b, } }, { 0x212a64dc, 0x43b1, 0x4d3d, { 0xa3, 0x0c, 0x2f, 0xc6, 0x9d, 0x20, 0x95, 0xc6 } } },
90 /* 001 */ { "W7\000Windows7\000", 25, 4, PWINGUID, { 0xb92e9980, 0xb9d5, 0x4821, { 0x9c, 0x94, 0x14, 0x0f, 0x63, 0x2f, 0x63, 0x12, } }, { 0x7fde5219, 0xfbfa, 0x484a, { 0x82, 0xc9, 0x34, 0xd1, 0xad, 0x53, 0xe8, 0x56 } } },
91 /* 002 */ { "W8\000Windows8\000", 25, 5, PWINGUID, { 0xa98bcd6d, 0x5343, 0x4603, { 0x8a, 0xfe, 0x59, 0x08, 0xe4, 0x61, 0x11, 0x12, } }, { 0x3c40b358, 0x5948, 0x45af, { 0x92, 0x3b, 0x53, 0xd2, 0x1f, 0xcc, 0x7e, 0x79 } } },
92 /* 003 */ { "W8C\000Windows8C\000", 25, 5, PWINGUID, { 0xc04ed6bf, 0x55c8, 0x4b47, { 0x9f, 0x8e, 0x5a, 0x1f, 0x31, 0xce, 0xee, 0x60, } }, { 0xbbb97b3b, 0x8ca4, 0x4a28, { 0x97, 0x17, 0x89, 0xfa, 0xbd, 0x42, 0xc4, 0xac } } },
93 /* 004 */ { "W81\000Windows81\000", 25, 6, PWINGUID, { 0xc06b6981, 0xd7fd, 0x4a35, { 0xb7, 0xb4, 0x05, 0x47, 0x42, 0xb7, 0xaf, 0x67, } }, { 0xcb8fc780, 0x2c05, 0x495a, { 0x97, 0x10, 0x85, 0xaf, 0xff, 0xc9, 0x04, 0xd7 } } },
94 /* 005 */ { "W81C\000Windows81C\000", 25, 6, PWINGUID, { 0xfe1c3238, 0x432a, 0x43a1, { 0x8e, 0x25, 0x97, 0xe7, 0xd1, 0xef, 0x10, 0xf3, } }, { 0x6d646890, 0x3606, 0x461a, { 0x86, 0xab, 0x59, 0x8b, 0xb8, 0x4a, 0xce, 0x82 } } },
95 /* 006 */ { "W10\000Windows10\000", 25, 6, PWINGUID, { 0x73111121, 0x5638, 0x40f6, { 0xbc, 0x11, 0xf1, 0xd7, 0xb0, 0xd6, 0x43, 0x00, } }, { 0x58e2134f, 0x8e11, 0x4d17, { 0x9c, 0xb2, 0x91, 0x06, 0x9c, 0x15, 0x11, 0x48 } } },
96 /* 007 */ { "W10C\000Windows10C\000", 25, 6, PWINGUID, { 0x58e97c99, 0xf377, 0x4ef1, { 0x81, 0xd5, 0x4a, 0xd5, 0x52, 0x2b, 0x5f, 0xd8, } }, { 0xe1c51358, 0xfe3e, 0x4203, { 0xa4, 0xa2, 0x3b, 0x6b, 0x20, 0xc9, 0x73, 0x4e } } },
97 /* 008 */ { "2008" "\0" "2008A\000", 5, 4, PWINGUID, { 0xddfa9f7c, 0xf09e, 0x40b9, { 0x8c, 0x1a, 0xbe, 0x87, 0x7a, 0x9a, 0x7f, 0x4b, } }, { 0x33e156e4, 0xb76f, 0x4a52, { 0x9f, 0x91, 0xf6, 0x41, 0xdd, 0x95, 0xac, 0x48 } } },
98 /* 009 */ { "2008B\000", 5, 4, PWINGUID, { 0xc1af4d90, 0xd1bc, 0x44ca, { 0x85, 0xd4, 0x00, 0x3b, 0xa3, 0x3d, 0xb3, 0xb9, } }, { 0x8fe53387, 0x3087, 0x4447, { 0x89, 0x85, 0xf7, 0x51, 0x32, 0x21, 0x5a, 0xc9 } } },
99 /* 010 */ { "2008C\000", 5, 4, PWINGUID, { 0x68b6e220, 0xcf09, 0x466b, { 0x92, 0xd3, 0x45, 0xcd, 0x96, 0x4b, 0x95, 0x09, } }, { 0x8a21fdf3, 0xcbc5, 0x44eb, { 0x83, 0xf3, 0xfe, 0x28, 0x4e, 0x66, 0x80, 0xa7 } } },
100 /* 011 */ { "2008R2" "\0" "2008R2A\000", 5, 4, PWINGUID, { 0xa78b8bd9, 0x8017, 0x4df5, { 0xb8, 0x6a, 0x09, 0xf7, 0x56, 0xaf, 0xfa, 0x7c, } }, { 0x0fc6ccaf, 0xff0e, 0x4fae, { 0x9d, 0x08, 0x43, 0x70, 0x78, 0x5b, 0xf7, 0xed } } },
101 /* 012 */ { "2008R2B\000", 5, 4, PWINGUID, { 0x620e2b3d, 0x09e7, 0x42fd, { 0x80, 0x2a, 0x17, 0xa1, 0x36, 0x52, 0xfe, 0x7a, } }, { 0xca87f5b6, 0xcd46, 0x40c0, { 0xb0, 0x6d, 0x8e, 0xcd, 0x57, 0xa4, 0x37, 0x3f } } },
102 /* 013 */ { "2008R2C\000", 5, 4, PWINGUID, { 0x7482e61b, 0xc589, 0x4b7f, { 0x8e, 0xcc, 0x46, 0xd4, 0x55, 0xac, 0x3b, 0x87, } }, { 0xb2ca2689, 0xa9a8, 0x42d7, { 0x93, 0x8d, 0xcf, 0x8e, 0x9f, 0x20, 0x19, 0x58 } } },
103 /* 014 */ { "2012\000", 5, 5, PWINGUID, { 0xf0f5ec41, 0x0d55, 0x4732, { 0xaf, 0x02, 0x44, 0x0a, 0x44, 0xa3, 0xcf, 0x0f, } }, { 0x8665cb71, 0x468c, 0x4aa3, { 0xa3, 0x37, 0xcb, 0x9b, 0xc9, 0xd5, 0xea, 0xac } } },
104 /* 015 */ { "2012R2\000" "12R2\000", 5, 6, PWINGUID, { 0x00091344, 0x1ea4, 0x4f37, { 0xb7, 0x89, 0x01, 0x75, 0x0b, 0xa6, 0x98, 0x8c, } }, { 0x8456EFD3, 0x0C04, 0x4089, { 0x87, 0x40, 0x5b, 0x72, 0x38, 0x53, 0x5a, 0x65 } } },
105 /* 016 */ { "Office2010\000O14\000", 5, 4, POFFICE2010GUID, { 0x6f327760, 0x8c5c, 0x417c, { 0x9b, 0x61, 0x83, 0x6a, 0x98, 0x28, 0x7e, 0x0c, } }, { 0xe85af946, 0x2e25, 0x47b7, { 0x83, 0xe1, 0xbe, 0xbc, 0xeb, 0xea, 0xc6, 0x11 } } },
106 /* 017 */ { "Office2013\000O15\000", 5, 6, POFFICE2013GUID, { 0xb322da9c, 0xa2e2, 0x4058, { 0x9e, 0x4e, 0xf5, 0x9a, 0x69, 0x70, 0xbd, 0x69, } }, { 0xe6a6f1bf, 0x9d40, 0x40c3, { 0xaa, 0x9f, 0xc7, 0x7b, 0xa2, 0x15, 0x78, 0xc0 } } },
107 /* 018 */ { "Office2013V5\000", 5, 5, POFFICE2013GUID, { 0xb322da9c, 0xa2e2, 0x4058, { 0x9e, 0x4e, 0xf5, 0x9a, 0x69, 0x70, 0xbd, 0x69, } }, { 0xe6a6f1bf, 0x9d40, 0x40c3, { 0xaa, 0x9f, 0xc7, 0x7b, 0xa2, 0x15, 0x78, 0xc0 } } },
108 /* 019 */ { "Office2016\000" "O16\000", 5, 6, POFFICE2013GUID, { 0xd450596f, 0x894d, 0x49e0, { 0x96, 0x6a, 0xfd, 0x39, 0xed, 0x4c, 0x4c, 0x64, } }, { 0x85b5f61b, 0x320b, 0x4be3, { 0x81, 0x4a, 0xb7, 0x6b, 0x2b, 0xfa, 0xfc, 0x82 } } },
109 /* 020 */ { NULL, 0, 0, NULL, { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } }, { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } } }
110 };
111
112
113 typedef struct
114 {
115 const char* first[16];
116 const char* second[16];
117 const char* tld[22];
118 } DnsNames;
119
120
121 // Some names for the DNS name random generator
122 static DnsNames ClientDnsNames =
123 {
124 { "www", "ftp", "kms", "hack-me", "smtp", "ns1", "mx1", "ns1", "pop3", "imap", "mail", "dns", "headquarter", "we-love", "_vlmcs._tcp", "ceo-laptop" },
125 { ".microsoft", ".apple", ".amazon", ".samsung", ".adobe", ".google", ".yahoo", ".facebook", ".ubuntu", ".oracle", ".borland", ".htc", ".acer", ".windows", ".linux", ".sony" },
126 { ".com", ".net", ".org", ".cn", ".co.uk", ".de", ".com.tw", ".us", ".fr", ".it", ".me", ".info", ".biz", ".co.jp", ".ua", ".at", ".es", ".pro", ".by", ".ru", ".pl", ".kr" }
127 };
128
129
130 // This is the one, we are actually using. We use Vista, if user selects nothing
131 LicensePack ActiveLicensePack;
132
133
134 // Request Count Control Variables
135 static int RequestsToGo = 1;
136 static BOOL firstRequestSent = FALSE;
137
138
139 static void string2UuidOrExit(const char *const restrict input, GUID *const restrict guid)
140 {
141 if (strlen(input) != GUID_STRING_LENGTH || !string2Uuid(input, guid))
142 {
143 errorout("Fatal: Command line contains an invalid GUID.\n");
144 exit(!0);
145 }
146 }
147
148
149 #ifndef NO_HELP
150
151 __noreturn static void clientUsage(const char* const programName)
152 {
153 errorout(
154 "vlmcs %s \n\n"
155 # ifndef NO_DNS
156 "Usage: %s [options] [ <host>[:<port>] | .<domain> | - ] [options]\n\n"
157 # else // DNS
158 "Usage: %s [options] [<host>[:<port>]] [options]\n\n"
159 # endif // DNS
160
161 "Options:\n\n"
162
163 " -v Be verbose\n"
164 " -l <app>\n"
165 " -4 Force V4 protocol\n"
166 " -5 Force V5 protocol\n"
167 " -6 Force V6 protocol\n"
168 # ifndef USE_MSRPC
169 " -i <IpVersion> Use IP protocol (4 or 6)\n"
170 # endif // USE_MSRPC
171 " -e Show some valid examples\n"
172 " -x Show valid Apps\n"
173 " -d no DNS names, use Netbios names (no effect if -w is used)\n\n"
174
175 "Advanced options:\n\n"
176
177 " -a <AppGUID> Use custom Application GUID\n"
178 " -s <ActGUID> Use custom Activation Configuration GUID\n"
179 " -k <KmsGUID> Use custom KMS GUID\n"
180 " -c <ClientGUID> Use custom Client GUID. Default: Use random\n"
181 " -o <PreviousClientGUID> Use custom Prevoius Client GUID. Default: ZeroGUID\n"
182 " -w <Workstation> Use custom workstation name. Default: Use random\n"
183 " -r <RequiredClientCount> Fake required clients\n"
184 " -n <Requests> Fixed # of requests (Default: Enough to charge)\n"
185 " -m Pretend to be a virtual machine\n"
186 " -G <file> Get ePID/HwId data and write to <file>. Can't be used with -l, -4, -5, -6, -a, -s, -k, -r and -n\n"
187 # ifndef USE_MSRPC
188 " -T Use a new TCP connection for each request.\n"
189 " -N <0|1> disable or enable NDR64. Default: 1\n"
190 " -B <0|1> disable or enable RPC bind time feature negotiation. Default: 1\n"
191 # endif // USE_MSRPC
192 " -t <LicenseStatus> Use specfic license status (0 <= T <= 6)\n"
193 " -g <BindingExpiration> Use a specfic binding expiration time in minutes. Default 43200\n"
194 # ifndef NO_DNS
195 " -P Ignore priority and weight in DNS SRV records\n"
196 # endif // NO_DNS
197 # ifndef USE_MSRPC
198 " -p Don't use multiplexed RPC bind\n"
199 # endif // USE_MSRPC
200 "\n"
201
202 "<port>:\t\tTCP port name of the KMS to use. Default 1688.\n"
203 "<host>:\t\thost name of the KMS to use. Default 127.0.0.1\n"
204 # ifndef NO_DNS
205 ".<domain>:\tfind KMS server in <domain> via DNS\n"
206 # endif // NO_DNS
207 "<app>:\t\t(Type %s -x to see a list of valid apps)\n\n",
208 Version, programName, programName
209 );
210
211 exit(!0);
212 }
213
214 __pure static int getLineWidth(void)
215 {
216 #ifdef TERMINAL_FIXED_WIDTH // For Toolchains that to not have winsize
217 return TERMINAL_FIXED_WIDTH;
218 #else // Can determine width of terminal
219 #ifndef _WIN32
220
221 struct winsize w;
222
223 if(ioctl(STDOUT_FILENO, TIOCGWINSZ, &w))
224 {
225 return 80; // Return this if stdout is not a tty
226 }
227
228 return w.ws_col;
229
230 #else // _WIN32
231
232 CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
233 HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
234
235 if (!GetConsoleScreenBufferInfo(hStdout, &csbiInfo))
236 {
237 return 80; // Return this if stdout is not a Console
238 }
239
240 return csbiInfo.srWindow.Right - csbiInfo.srWindow.Left;
241
242 #endif // WIN32
243
244 #endif // Can determine width of terminal
245
246 }
247
248 __noreturn static void showProducts(PRINTFUNC p)
249 {
250 int cols = getLineWidth();
251 int itemsPerLine;
252 uint8_t i;
253
254 p(
255 "The following "
256 #if !defined(NO_EXTENDED_PRODUCT_LIST) && !defined(NO_BASIC_PRODUCT_LIST)
257 "aliases "
258 #else
259 "names "
260 #endif
261 "can be used with -l:\n\n"
262 );
263
264 const LicensePack* lp;
265
266 itemsPerLine = cols / 20;
267 if (!itemsPerLine) itemsPerLine = 1;
268
269 for (i = 1, lp = LicensePackList; lp->names; lp++)
270 {
271 const char* name;
272
273 for (name = lp->names; *name; name += strlen(name) + 1, i++)
274 {
275 p("%-20s", name);
276
277 if (!(i % itemsPerLine)) p("\n");
278 }
279 }
280
281 p("\n\n");
282
283 #if !defined(NO_EXTENDED_PRODUCT_LIST) && !defined(NO_BASIC_PRODUCT_LIST)
284
285 const KmsIdList* currentProduct;
286 uint_fast8_t longestString = 0;
287 uint8_t k, items = getExtendedProductListSize();
288
289 p("You may also use these product names or numbers:\n\n");
290
291 for (currentProduct = ExtendedProductList; currentProduct->name; currentProduct++)
292 {
293 uint_fast8_t len = strlen(currentProduct->name);
294
295 if (len > longestString)
296 longestString = len;
297 }
298
299 itemsPerLine = cols / (longestString + 10);
300 if (!itemsPerLine) itemsPerLine = 1;
301 uint8_t lines = items / itemsPerLine;
302 if (items % itemsPerLine) lines++;
303
304 for (i = 0; i < lines; i++)
305 {
306 for (k = 0; k < itemsPerLine; k++)
307 {
308 uint8_t j;
309 uint8_t index = k * lines + i;
310
311 if (index >= items) break;
312
313 p("%3u = %s", index + 1, ExtendedProductList[index].name);
314
315 for (j = 0; j < longestString + 4 - strlen(ExtendedProductList[index].name); j++)
316 {
317 p(" ");
318 }
319 }
320
321 p("\n");
322 }
323
324 p("\n");
325
326 #endif // !defined(NO_EXTENDED_PRODUCT_LIST) && !defined(NO_BASIC_PRODUCT_LIST)
327
328 exit(0);
329 }
330
331 __noreturn static void examples(const char* const programName)
332 {
333 printf(
334 "\nRequest activation for Office2013 using V4 protocol from 192.168.1.5:1688\n"
335 "\t%s -l O15 -4 192.168.1.5\n"
336 "\t%s -l O15 -4 192.168.1.5:1688\n\n"
337
338 "Request activation for Windows Server 2012 using V4 protocol from localhost:1688\n"
339 "\t%s -4 -l Windows -k 8665cb71-468c-4aa3-a337-cb9bc9d5eaac\n"
340 "\t%s -4 -l 2012\n"
341 "\t%s -4 -l 2012 [::1]:1688\n"
342 "\t%s -4 -l 12 127.0.0.2:1688\n\n"
343
344 "Send 100,000 requests to localhost:1688\n"
345 "\t%s -n 100000 -l Office2010\n\n"
346
347 "Request Activation for Windows 8 from 10.0.0.1:4711 and pretend to be Steve Ballmer\n"
348 "\t%s -l Windows8 -w steveb1.redmond.microsoft.com 10.0.0.1:4711\n\n",
349 programName, programName, programName, programName, programName, programName, programName, programName
350 );
351
352 exit(0);
353 }
354
355
356 #else // NO_HELP
357
358
359 __noreturn static void clientUsage(const char* const programName)
360 {
361 errorout("Incorrect parameter specified.\n");
362 exit(!0);
363 }
364
365
366 #endif // NO_HELP
367
368
369 static BOOL findLicensePackByName(const char* const name, LicensePack* const lp)
370 {
371 // Try to find a package in the short list first
372
373 LicensePack *licensePack;
374 for (licensePack = (LicensePack*)&LicensePackList; licensePack->names; licensePack ++)
375 {
376 const char *currentName;
377 for (currentName = licensePack->names; *currentName; currentName += strlen(currentName) + 1)
378 {
379 if (!strcasecmp(name, currentName))
380 {
381 *lp = *licensePack;
382 return TRUE;
383 }
384 }
385 }
386
387 #if defined(NO_BASIC_PRODUCT_LIST) || defined(NO_EXTENDED_PRODUCT_LIST)
388
389 return FALSE;
390
391 #else // Both Lists are available
392
393 // search extended product list
394
395 uint8_t items = getExtendedProductListSize();
396 unsigned int index;
397
398 if (stringToInt(name, 1, items, &index))
399 {
400 index--;
401 }
402 else
403 {
404 for (index = 0; index < items; index++)
405 {
406 if (!strcasecmp(ExtendedProductList[index].name, name)) break;
407 }
408
409 if (index >= items) return FALSE;
410 }
411
412 lp->AppID = &AppList[ExtendedProductList[index].AppIndex].guid;
413 lp->KMSID = ProductList[ExtendedProductList[index].KmsIndex].guid;
414 lp->ActID = ExtendedProductList[index].guid;
415 lp->N_Policy = ProductList[ExtendedProductList[index].KmsIndex].KMS_PARAM_REQUIREDCOUNT;
416 lp->kmsVersionMajor = ProductList[ExtendedProductList[index].KmsIndex].KMS_PARAM_MAJOR;
417
418 return TRUE;
419
420 #endif // Both Lists are available
421 }
422
423 static const char* const client_optstring = "+N:B:i:l:a:s:k:c:w:r:n:t:g:G:o:pPTv456mexd";
424
425
426 //First pass. We handle only "-l". Since -a -k -s -4 -5 and -6 are exceptions to -l, we process -l first
427 static void parseCommandLinePass1(const int argc, CARGV argv)
428 {
429 int o;
430 optReset();
431
432 for (opterr = 0; ( o = getopt(argc, (char* const*)argv, client_optstring) ) > 0; ) switch (o)
433 {
434 case 'l': // Set "License Pack" and protocol version (e.g. Windows8, Office2013v5, ...)
435
436 if (!findLicensePackByName(optarg, &ActiveLicensePack))
437 {
438 errorout("Invalid client application. \"%s\" is not valid for -l.\n\n", optarg);
439 #ifndef NO_HELP
440 showProducts(&errorout);
441 #endif // !NO_HELP
442 }
443
444 break;
445
446 default:
447 break;
448 }
449 }
450
451
452 // Second Pass. Handle all options except "-l"
453 static void parseCommandLinePass2(const char *const programName, const int argc, CARGV argv)
454 {
455 int o;
456 optReset();
457
458 for (opterr = 0; ( o = getopt(argc, (char* const*)argv, client_optstring) ) > 0; ) switch (o)
459 {
460 #ifndef NO_HELP
461
462 case 'e': // Show examples
463
464 examples(programName);
465 break;
466
467 case 'x': // Show Apps
468
469 showProducts(&printf);
470 break;
471
472 #endif // NO_HELP
473
474 # ifndef NO_DNS
475
476 case 'P':
477
478 NoSrvRecordPriority = TRUE;
479 break;
480
481 # endif // NO_DNS
482
483 case 'G':
484
485 incompatibleOptions |= VLMCS_OPTION_GRAB_INI;
486 fn_ini_client = optarg;
487 break;
488
489 # ifndef USE_MSRPC
490
491 case 'N':
492 if (!getArgumentBool(&UseRpcNDR64, optarg)) clientUsage(programName);
493 break;
494
495 case 'B':
496 if (!getArgumentBool(&UseRpcBTFN, optarg)) clientUsage(programName);
497 break;
498
499 case 'i':
500
501 switch(getOptionArgumentInt(o, 4, 6))
502 {
503 case 4:
504 AddressFamily = AF_INET;
505 break;
506 case 6:
507 AddressFamily = AF_INET6;
508 break;
509 default:
510 errorout("IPv5 does not exist.\n");
511 exit(!0);
512 break;
513 }
514
515 break;
516
517 case 'p': // Multiplexed RPC
518
519 UseMultiplexedRpc = FALSE;
520 break;
521
522 # endif // USE_MSRPC
523
524 case 'n': // Fixed number of Requests (regardless, whether they are required)
525
526 incompatibleOptions |= VLMCS_OPTION_NO_GRAB_INI;
527 FixedRequests = getOptionArgumentInt(o, 1, INT_MAX);
528 break;
529
530 case 'r': // Fake minimum required client count
531
532 incompatibleOptions |= VLMCS_OPTION_NO_GRAB_INI;
533 ActiveLicensePack.N_Policy = getOptionArgumentInt(o, 1, INT_MAX);
534 break;
535
536 case 'c': // use a specific client GUID
537
538 // If using a constant Client ID, send only one request unless /N= explicitly specified
539 if (!FixedRequests) FixedRequests = 1;
540
541 CMID = optarg;
542 break;
543
544 case 'o': // use a specific previous client GUID
545
546 CMID_prev = optarg;
547 break;
548
549 case 'a': // Set specific App Id
550
551 incompatibleOptions |= VLMCS_OPTION_NO_GRAB_INI;
552 ActiveLicensePack.AppID = (GUID*)vlmcsd_malloc(sizeof(GUID));
553
554 string2UuidOrExit(optarg, (GUID*)ActiveLicensePack.AppID);
555 break;
556
557 case 'g': // Set custom "grace" time in minutes (default 30 days)
558
559 BindingExpiration = getOptionArgumentInt(o, 0, INT_MAX);
560 break;
561
562 case 's': // Set specfic SKU ID
563
564 incompatibleOptions |= VLMCS_OPTION_NO_GRAB_INI;
565 string2UuidOrExit(optarg, &ActiveLicensePack.ActID);
566 break;
567
568 case 'k': // Set specific KMS ID
569
570 incompatibleOptions |= VLMCS_OPTION_NO_GRAB_INI;
571 string2UuidOrExit(optarg, &ActiveLicensePack.KMSID);
572 break;
573
574 case '4': // Force V4 protocol
575 case '5': // Force V5 protocol
576 case '6': // Force V5 protocol
577
578 incompatibleOptions |= VLMCS_OPTION_NO_GRAB_INI;
579 ActiveLicensePack.kmsVersionMajor = o - 0x30;
580 break;
581
582 case 'd': // Don't use DNS names
583
584 dnsnames = FALSE;
585 break;
586
587 case 'v': // Be verbose
588
589 verbose = TRUE;
590 break;
591
592 case 'm': // Pretend to be a virtual machine
593
594 VMInfo = TRUE;
595 break;
596
597 case 'w': // WorkstationName (max. 63 chars)
598
599 WorkstationName = optarg;
600
601 if (strlen(WorkstationName) > 63)
602 {
603 errorout("\007WARNING! Truncating Workstation name to 63 characters (%s).\n", WorkstationName);
604 }
605
606 break;
607
608 case 't':
609
610 LicenseStatus = getOptionArgumentInt(o, 0, 6) & 0xff;
611 break;
612
613 # ifndef USE_MSRPC
614
615 case 'T':
616
617 ReconnectForEachRequest = TRUE;
618 break;
619
620 # endif // USE_MSRPC
621
622 case 'l':
623 incompatibleOptions |= VLMCS_OPTION_NO_GRAB_INI;
624 break;
625
626 default:
627 clientUsage(programName);
628 }
629 if ((incompatibleOptions & (VLMCS_OPTION_NO_GRAB_INI | VLMCS_OPTION_GRAB_INI)) == (VLMCS_OPTION_NO_GRAB_INI | VLMCS_OPTION_GRAB_INI))
630 clientUsage(programName);
631 }
632
633
634 /*
635 * Compares 2 GUIDs where one is host-endian and the other is little-endian (network byte order)
636 */
637 int_fast8_t IsEqualGuidLEHE(const GUID* const guid1, const GUID* const guid2)
638 {
639 GUID tempGuid;
640 LEGUID(&tempGuid, guid2);
641 return IsEqualGUID(guid1, &tempGuid);
642 }
643
644
645 #ifndef USE_MSRPC
646 static void checkRpcLevel(const REQUEST* request, RESPONSE* response)
647 {
648 if (!RpcFlags.HasNDR32)
649 errorout("\nWARNING: Server's RPC protocol does not support NDR32.\n");
650
651 if (UseRpcBTFN && UseRpcNDR64 && RpcFlags.HasNDR64 && !RpcFlags.HasBTFN)
652 errorout("\nWARNING: Server's RPC protocol has NDR64 but no BTFN.\n");
653
654 if (!IsEqualGuidLEHE(&request->KMSID, &ProductList[15].guid) && UseRpcBTFN && !RpcFlags.HasBTFN)
655 errorout("\nWARNING: A server with pre-Vista RPC activated a product other than Office 2010.\n");
656 }
657 #endif // USE_MSRPC
658
659
660 static void displayResponse(const RESPONSE_RESULT result, const REQUEST* request, RESPONSE* response, BYTE *hwid)
661 {
662 fflush(stdout);
663
664 if (!result.RpcOK) errorout("\n\007ERROR: Non-Zero RPC result code.\n");
665 if (!result.DecryptSuccess) errorout("\n\007ERROR: Decryption of V5/V6 response failed.\n");
666 if (!result.IVsOK) errorout("\n\007ERROR: AES CBC initialization vectors (IVs) of request and response do not match.\n");
667 if (!result.PidLengthOK) errorout("\n\007ERROR: The length of the PID is not valid.\n");
668 if (!result.HashOK) errorout("\n\007ERROR: Computed hash does not match hash in response.\n");
669 if (!result.ClientMachineIDOK) errorout("\n\007ERROR: Client machine GUIDs of request and response do not match.\n");
670 if (!result.TimeStampOK) errorout("\n\007ERROR: Time stamps of request and response do not match.\n");
671 if (!result.VersionOK) errorout("\n\007ERROR: Protocol versions of request and response do not match.\n");
672 if (!result.HmacSha256OK) errorout("\n\007ERROR: Keyed-Hash Message Authentication Code (HMAC) is incorrect.\n");
673 if (!result.IVnotSuspicious) errorout("\nWARNING: Response uses an IV following KMSv5 rules in KMSv6 protocol.\n");
674
675 if (result.effectiveResponseSize != result.correctResponseSize)
676 {
677 errorout("\n\007WARNING: Size of RPC payload (KMS Message) should be %u but is %u.", result.correctResponseSize, result.effectiveResponseSize);
678 }
679
680 # ifndef USE_MSRPC
681 checkRpcLevel(request, response);
682 # endif // USE_MSRPC
683
684 if (!result.DecryptSuccess) return; // Makes no sense to display anything
685
686 char ePID[3 * PID_BUFFER_SIZE];
687 if (!ucs2_to_utf8(response->KmsPID, ePID, PID_BUFFER_SIZE, 3 * PID_BUFFER_SIZE))
688 {
689 memset(ePID + 3 * PID_BUFFER_SIZE - 3, 0, 3);
690 }
691
692 // Read KMSPID from Response
693 if (!verbose)
694 {
695 printf(" -> %s", ePID);
696
697 if (LE16(response->MajorVer) > 5)
698 {
699 # ifndef _WIN32
700 printf(" (%016llX)", (unsigned long long)BE64(*(uint64_t*)hwid));
701 # else // _WIN32
702 printf(" (%016I64X)", (unsigned long long)BE64(*(uint64_t*)hwid));
703 # endif // _WIN32
704 }
705
706 printf("\n");
707 }
708 else
709 {
710 printf(
711 "\n\nResponse from KMS server\n========================\n\n"
712 "Size of KMS Response : %u (0x%x)\n", result.effectiveResponseSize, result.effectiveResponseSize
713 );
714
715 logResponseVerbose(ePID, hwid, response, &printf);
716 printf("\n");
717 }
718 }
719
720
721 static void connectRpc(RpcCtx *s)
722 {
723 # ifdef NO_DNS
724
725 *s = connectToAddress(RemoteAddr, AddressFamily, FALSE);
726 if (*s == INVALID_RPCCTX)
727 {
728 errorout("Fatal: Could not connect to %s\n", RemoteAddr);
729 exit(!0);
730 }
731
732 if (verbose)
733 printf("\nPerforming RPC bind ...\n");
734
735 if (rpcBindClient(*s, verbose))
736 {
737 errorout("Fatal: Could not bind RPC\n");
738 exit(!0);
739 }
740
741 if (verbose) printf("... successful\n");
742
743 # else // DNS
744
745 static kms_server_dns_ptr* serverlist = NULL;
746 static int numServers = 0;
747 //static int_fast8_t ServerListAlreadyPrinted = FALSE;
748 int i;
749
750 if (!strcmp(RemoteAddr, "-") || *RemoteAddr == '.') // Get KMS server via DNS SRV record
751 {
752 if (!serverlist)
753 numServers = getKmsServerList(&serverlist, RemoteAddr);
754
755 if (numServers < 1)
756 {
757 errorout("Fatal: No KMS servers found\n");
758 exit(!0);
759 }
760
761 if (!NoSrvRecordPriority) sortSrvRecords(serverlist, numServers);
762
763 if (verbose /*&& !ServerListAlreadyPrinted*/)
764 {
765 for (i = 0; i < numServers; i++)
766 {
767 printf(
768 "Found %-40s (priority: %hu, weight: %hu, randomized weight: %i)\n",
769 serverlist[i]->serverName,
770 serverlist[i]->priority, serverlist[i]->weight,
771 NoSrvRecordPriority ? 0 : serverlist[i]->random_weight
772 );
773 }
774
775 printf("\n");
776 //ServerListAlreadyPrinted = TRUE;
777 }
778 }
779 else // Just use the server supplied on the command line
780 {
781 if (!serverlist)
782 {
783 serverlist = (kms_server_dns_ptr*)vlmcsd_malloc(sizeof(kms_server_dns_ptr));
784 *serverlist = (kms_server_dns_ptr)vlmcsd_malloc(sizeof(kms_server_dns_t));
785
786 numServers = 1;
787 strncpy((*serverlist)->serverName, RemoteAddr, sizeof((*serverlist)->serverName));
788 }
789 }
790
791 for (i = 0; i < numServers; i++)
792 {
793 *s = connectToAddress(serverlist[i]->serverName, AddressFamily, (*RemoteAddr == '.' || *RemoteAddr == '-'));
794
795 if (*s == INVALID_RPCCTX) continue;
796
797 if (verbose)
798 printf("\nPerforming RPC bind ...\n");
799
800 if (rpcBindClient(*s, verbose))
801 {
802 errorout("Warning: Could not bind RPC\n");
803 continue;
804 }
805
806 if (verbose) printf("... successful\n");
807
808 return;
809 }
810
811 errorout("Fatal: Could not connect to any KMS server\n");
812 exit(!0);
813
814 # endif // DNS
815 }
816
817
818 static int SendActivationRequest(const RpcCtx sock, RESPONSE *baseResponse, REQUEST *baseRequest, RESPONSE_RESULT *result, BYTE *const hwid)
819 {
820 size_t requestSize, responseSize;
821 BYTE *request, *response;
822 int status;
823
824 result->mask = 0;
825
826 if (LE16(baseRequest->MajorVer) == 4)
827 request = CreateRequestV4(&requestSize, baseRequest);
828 else
829 request = CreateRequestV6(&requestSize, baseRequest);
830
831 if (!(status = rpcSendRequest(sock, request, requestSize, &response, &responseSize)))
832 {
833 if (LE16(((RESPONSE*)(response))->MajorVer) == 4)
834 {
835 RESPONSE_V4 response_v4;
836 *result = DecryptResponseV4(&response_v4, responseSize, response, request);
837 memcpy(baseResponse, &response_v4.ResponseBase, sizeof(RESPONSE));
838 }
839 else
840 {
841 RESPONSE_V6 response_v6;
842 *result = DecryptResponseV6(&response_v6, responseSize, response, request, hwid);
843 memcpy(baseResponse, &response_v6.ResponseBase, sizeof(RESPONSE));
844 }
845
846 result->RpcOK = TRUE;
847 }
848
849 if (response) free(response);
850 free(request);
851 return status;
852 }
853
854
855 static int sendRequest(RpcCtx *const s, REQUEST *const request, RESPONSE *const response, hwid_t hwid, RESPONSE_RESULT *const result)
856 {
857 CreateRequestBase(request);
858
859 if (*s == INVALID_RPCCTX )
860 connectRpc(s);
861 else
862 {
863 // Check for lame KMS emulators that close the socket after each request
864 int_fast8_t disconnected = isDisconnected(*s);
865
866 if (disconnected)
867 errorout("\nWarning: Server closed RPC connection (probably non-multitasked KMS emulator)\n");
868
869 if (ReconnectForEachRequest || disconnected)
870 {
871 closeRpc(*s);
872 connectRpc(s);
873 }
874 }
875
876 printf("Sending activation request (KMS V%u) ", ActiveLicensePack.kmsVersionMajor);
877 fflush(stdout);
878
879 return SendActivationRequest(*s, response, request, result, hwid);
880 }
881
882
883 static void displayRequestError(RpcCtx *const s, const int status, const int currentRequest, const int totalRequests)
884 {
885 errorout("\nError 0x%08X while sending request %u of %u\n", status, currentRequest, RequestsToGo + totalRequests);
886
887 switch(status)
888 {
889 case 0xC004F042: // not licensed
890 errorout("The server refused to activate the requested product\n");
891 break;
892
893 case 0x8007000D: // e.g. v6 protocol on a v5 server
894 errorout("The server didn't understand the request\n");
895 break;
896
897 case 1:
898 errorout("An RPC protocol error has occured\n");
899 closeRpc(*s);
900 connectRpc(s);
901 break;
902
903 default:
904 break;
905 }
906 }
907
908
909 static void newIniBackupFile(const char* const restrict fname)
910 {
911 FILE *restrict f = fopen(fname, "wb");
912
913 if (!f)
914 {
915 errorout("Fatal: Cannot create %s: %s\n", fname, strerror(errno));
916 exit(!0);
917 }
918
919 if (fclose(f))
920 {
921 errorout("Fatal: Cannot write to %s: %s\n", fname, strerror(errno));
922 unlink(fname);
923 exit(!0);
924 }
925 }
926
927
928 static void updateIniFile(iniFileEpidLines* const restrict lines)
929 {
930 int_fast8_t lineWritten[_countof(*lines)];
931 struct stat statbuf;
932 uint_fast8_t i;
933 int_fast8_t iniFileExistedBefore = TRUE;
934 unsigned int lineNumber;
935
936 memset(lineWritten, FALSE, sizeof(lineWritten));
937
938 char* restrict fn_bak = (char*)vlmcsd_malloc(strlen(fn_ini_client) + 2);
939
940 strcpy(fn_bak, fn_ini_client);
941 strcat(fn_bak, "~");
942
943 if (stat(fn_ini_client, &statbuf))
944 {
945 if (errno != ENOENT)
946 {
947 errorout("Fatal: %s: %s\n", fn_ini_client, strerror(errno));
948 exit(!0);
949 }
950 else
951 {
952 iniFileExistedBefore = FALSE;
953 newIniBackupFile(fn_bak);
954 }
955 }
956 else
957 {
958 unlink(fn_bak); // Required for Windows. Most Unix systems don't need it.
959 if (rename(fn_ini_client, fn_bak))
960 {
961 errorout("Fatal: Cannot create %s: %s\n", fn_bak, strerror(errno));
962 exit(!0);
963 }
964 }
965
966 printf("\n%s file %s\n", iniFileExistedBefore ? "Updating" : "Creating", fn_ini_client);
967
968 FILE *restrict in, *restrict out;
969
970 in = fopen(fn_bak, "rb");
971
972 if (!in)
973 {
974 errorout("Fatal: Cannot open %s: %s\n", fn_bak, strerror(errno));
975 exit(!0);
976 }
977
978 out = fopen(fn_ini_client, "wb");
979
980 if (!out)
981 {
982 errorout("Fatal: Cannot create %s: %s\n", fn_ini_client, strerror(errno));
983 exit(!0);
984 }
985
986 char sourceLine[256];
987
988 for (lineNumber = 1; fgets(sourceLine, sizeof(sourceLine), in); lineNumber++)
989 {
990 for (i = 0; i < _countof(*lines); i++)
991 {
992 if (*(*lines)[i] && !strncasecmp(sourceLine, (*lines)[i], GUID_STRING_LENGTH))
993 {
994 if (lineWritten[i]) break;
995
996 fprintf(out, "%s", (*lines)[i]);
997 printf("line %2i: %s", lineNumber, (*lines)[i]);
998 lineWritten[i] = TRUE;
999 break;
1000 }
1001 }
1002
1003 if (i >= _countof(*lines))
1004 {
1005 fprintf(out, "%s", sourceLine);
1006 }
1007 }
1008
1009 if (ferror(in))
1010 {
1011 errorout("Fatal: Cannot read from %s: %s\n", fn_bak, strerror(errno));
1012 exit(!0);
1013 }
1014
1015 fclose(in);
1016
1017 for (i = 0; i < _countof(*lines); i++)
1018 {
1019 if (!lineWritten[i] && *(*lines)[i])
1020 {
1021 fprintf(out, "%s", (*lines)[i]);
1022 printf("line %2i: %s", lineNumber + i, (*lines)[i]);
1023 }
1024 }
1025
1026 if (fclose(out))
1027 {
1028 errorout("Fatal: Cannot write to %s: %s\n", fn_ini_client, strerror(errno));
1029 exit(!0);
1030 }
1031
1032 if (!iniFileExistedBefore) unlink(fn_bak);
1033
1034 free(fn_bak);
1035 }
1036
1037 static void grabServerData()
1038 {
1039 RpcCtx s = INVALID_RPCCTX;
1040 WORD MajorVer = 6;
1041 iniFileEpidLines lines;
1042 int_fast8_t Licenses[_countof(lines)] = { 0, 15, 14 };
1043 uint_fast8_t i;
1044 RESPONSE response;
1045 RESPONSE_RESULT result;
1046 REQUEST request;
1047 hwid_t hwid;
1048 int status;
1049 size_t len;
1050
1051 for (i = 0; i < _countof(lines); i++) *lines[i] = 0;
1052
1053 for (i = 0; i < _countof(Licenses) && MajorVer > 3; i++)
1054 {
1055 ActiveLicensePack = LicensePackList[Licenses[i]];
1056 ActiveLicensePack.kmsVersionMajor = MajorVer;
1057 status = sendRequest(&s, &request, &response, hwid, &result);
1058 printf("%-11s", ActiveLicensePack.names);
1059
1060 if (status)
1061 {
1062 displayRequestError(&s, status, i + 7 - MajorVer, 9 - MajorVer);
1063
1064 if (status == 1) break;
1065
1066 if ((status & 0xF0000000) == 0x80000000)
1067 {
1068 MajorVer--;
1069 i--;
1070 }
1071
1072 continue;
1073 }
1074
1075 printf("%i of %i", (int)(i + 7 - MajorVer), (int)(9 - MajorVer));
1076 displayResponse(result, &request, &response, hwid);
1077
1078 char guidBuffer[GUID_STRING_LENGTH + 1];
1079 char ePID[3 * PID_BUFFER_SIZE];
1080
1081 uuid2StringLE(&request.AppID, guidBuffer);
1082
1083 if (!ucs2_to_utf8(response.KmsPID, ePID, PID_BUFFER_SIZE, 3 * PID_BUFFER_SIZE))
1084 {
1085 memset(ePID + 3 * PID_BUFFER_SIZE - 3, 0, 3);
1086 }
1087
1088 snprintf(lines[i], sizeof(lines[0]), "%s = %s", guidBuffer, ePID);
1089
1090 if (response.MajorVer > 5)
1091 {
1092 len = strlen(lines[i]);
1093 snprintf (lines[i] + len, sizeof(lines[0]) - len, "/ %02X %02X %02X %02X %02X %02X %02X %02X", hwid[0], hwid[1], hwid[2], hwid[3], hwid[4], hwid[5], hwid[6], hwid[7]);
1094 }
1095
1096 len = strlen(lines[i]);
1097 snprintf(lines[i] + len, sizeof(lines[0]) - len, "\n");
1098
1099 }
1100
1101 if (strcmp(fn_ini_client, "-"))
1102 {
1103 updateIniFile(&lines);
1104 }
1105 else
1106 {
1107 printf("\n");
1108 for (i = 0; i < _countof(lines); i++) printf("%s", lines[i]);
1109 }
1110 }
1111
1112
1113 int client_main(const int argc, CARGV argv)
1114 {
1115 #if defined(_WIN32) && !defined(USE_MSRPC)
1116
1117 // Windows Sockets must be initialized
1118
1119 WSADATA wsadata;
1120 int error;
1121
1122 if ((error = WSAStartup(0x0202, &wsadata)))
1123 {
1124 printerrorf("Fatal: Could not initialize Windows sockets (Error: %d).\n", error);
1125 return error;
1126 }
1127
1128 #endif // _WIN32
1129
1130 #ifdef _NTSERVICE
1131
1132 // We are not a service
1133 IsNTService = FALSE;
1134
1135 // Set console output page to UTF-8
1136 // SetConsoleOutputCP(65001);
1137
1138 #endif // _NTSERVICE
1139
1140 randomNumberInit();
1141 ActiveLicensePack = *LicensePackList; //first license is Windows Vista
1142
1143 parseCommandLinePass1(argc, argv);
1144
1145 int_fast8_t useDefaultHost = FALSE;
1146
1147 if (optind < argc)
1148 RemoteAddr = argv[optind];
1149 else
1150 useDefaultHost = TRUE;
1151
1152 int hostportarg = optind;
1153
1154 if (optind < argc - 1)
1155 {
1156 parseCommandLinePass1(argc - hostportarg, argv + hostportarg);
1157
1158 if (optind < argc - hostportarg)
1159 clientUsage(argv[0]);
1160 }
1161
1162 parseCommandLinePass2(argv[0], argc, argv);
1163
1164 if (optind < argc - 1)
1165 parseCommandLinePass2(argv[0], argc - hostportarg, argv + hostportarg);
1166
1167 if (useDefaultHost)
1168 RemoteAddr = AddressFamily == AF_INET6 ? "::1" : "127.0.0.1";
1169
1170 if (fn_ini_client != NULL)
1171 grabServerData();
1172 else
1173 {
1174 int requests;
1175 RpcCtx s = INVALID_RPCCTX;
1176
1177 for (requests = 0, RequestsToGo = ActiveLicensePack.N_Policy - 1; RequestsToGo; requests++)
1178 {
1179 RESPONSE response;
1180 REQUEST request;
1181 RESPONSE_RESULT result;
1182 hwid_t hwid;
1183
1184 int status = sendRequest(&s, &request, &response, hwid, &result);
1185
1186 if (FixedRequests) RequestsToGo = FixedRequests - requests - 1;
1187
1188 if (status)
1189 {
1190 displayRequestError(&s, status, requests + 1, RequestsToGo + requests + 1);
1191 if (!FixedRequests) RequestsToGo = 0;
1192 }
1193 else
1194 {
1195 if (!FixedRequests)
1196 {
1197 if (firstRequestSent && ActiveLicensePack.N_Policy - (int)response.Count >= RequestsToGo)
1198 {
1199 errorout("\nThe KMS server does not increment it's active clients. Aborting...\n");
1200 RequestsToGo = 0;
1201 }
1202 else
1203 {
1204 RequestsToGo = ActiveLicensePack.N_Policy - response.Count;
1205 if (RequestsToGo < 0) RequestsToGo = 0;
1206 }
1207 }
1208
1209 fflush(stderr);
1210 printf("%i of %i ", requests + 1, RequestsToGo + requests + 1);
1211 displayResponse(result, &request, &response, hwid);
1212 firstRequestSent = TRUE;
1213 }
1214 }
1215 }
1216
1217 return 0;
1218 }
1219
1220
1221 // Create Base KMS Client Request
1222 static void CreateRequestBase(REQUEST *Request)
1223 {
1224
1225 Request->MinorVer = LE16((WORD)kmsVersionMinor);
1226 Request->MajorVer = LE16((WORD)ActiveLicensePack.kmsVersionMajor);
1227 Request->VMInfo = LE32(VMInfo);
1228 Request->LicenseStatus = LE32(LicenseStatus);
1229 Request->BindingExpiration = LE32(BindingExpiration);
1230 LEGUID(&Request->AppID, ActiveLicensePack.AppID);
1231 LEGUID(&Request->ActID, &ActiveLicensePack.ActID);
1232 LEGUID(&Request->KMSID, &ActiveLicensePack.KMSID);
1233
1234 getUnixTimeAsFileTime(&Request->ClientTime);
1235 Request->N_Policy = LE32(ActiveLicensePack.N_Policy);
1236
1237 {
1238 GUID tempGUID;
1239
1240 if (CMID)
1241 {
1242 string2UuidOrExit(CMID, &tempGUID);
1243 LEGUID(&Request->CMID, &tempGUID);
1244 }
1245 else
1246 {
1247 get16RandomBytes(&Request->CMID);
1248
1249 // Set reserved UUID bits
1250 Request->CMID.Data4[0] &= 0x3F;
1251 Request->CMID.Data4[0] |= 0x80;
1252
1253 // Set UUID type 4 (random UUID)
1254 Request->CMID.Data3 &= LE16(0xfff);
1255 Request->CMID.Data3 |= LE16(0x4000);
1256 }
1257
1258 if (CMID_prev)
1259 {
1260 string2UuidOrExit(CMID_prev, &tempGUID);
1261 LEGUID(&Request->CMID_prev, &tempGUID);
1262 }
1263 else
1264 {
1265 memset(&Request->CMID_prev, 0, sizeof(Request->CMID_prev));
1266 }
1267 }
1268
1269 static const char alphanum[] = "0123456789" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" /*"abcdefghijklmnopqrstuvwxyz" */;
1270
1271 if (WorkstationName)
1272 {
1273 utf8_to_ucs2(Request->WorkstationName, WorkstationName, WORKSTATION_NAME_BUFFER, WORKSTATION_NAME_BUFFER * 3);
1274 }
1275 else if (dnsnames)
1276 {
1277 int len, len2;
1278 unsigned int index = rand() % _countof(ClientDnsNames.first);
1279 len = utf8_to_ucs2(Request->WorkstationName, ClientDnsNames.first[index], WORKSTATION_NAME_BUFFER, WORKSTATION_NAME_BUFFER * 3);
1280
1281 index = rand() % _countof(ClientDnsNames.second);
1282 len2 = utf8_to_ucs2(Request->WorkstationName + len, ClientDnsNames.second[index], WORKSTATION_NAME_BUFFER, WORKSTATION_NAME_BUFFER * 3);
1283
1284 index = rand() % _countof(ClientDnsNames.tld);
1285 utf8_to_ucs2(Request->WorkstationName + len + len2, ClientDnsNames.tld[index], WORKSTATION_NAME_BUFFER, WORKSTATION_NAME_BUFFER * 3);
1286 }
1287 else
1288 {
1289 unsigned int size = (rand() % 14) + 1;
1290 const unsigned char *dummy;
1291 unsigned int i;
1292
1293 for (i = 0; i < size; i++)
1294 {
1295 Request->WorkstationName[i] = utf8_to_ucs2_char((unsigned char*)alphanum + (rand() % (sizeof(alphanum) - 1)), &dummy);
1296 }
1297
1298 Request->WorkstationName[size] = 0;
1299 }
1300
1301 //Show Details
1302 if (verbose)
1303 {
1304 printf("\nRequest Parameters\n==================\n\n");
1305 logRequestVerbose(Request, &printf);
1306 printf("\n");
1307 }
1308 }
1309
1310
A place to share codes with mates