OpenWrt – Blame information for rev 4

Subversion Repositories:
Rev:
Rev Author Line No. Line
4 office 1 /*
2 * Copyright (C) 2009-2011 Gabor Juhos <juhosg@openwrt.org>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 as published
6 * by the Free Software Foundation.
7 *
8 */
9  
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <stdint.h>
13 #include <string.h>
14 #include <libgen.h>
15 #include <getopt.h> /* for getopt() */
16 #include <stdarg.h>
17  
18 #include "buffalo-lib.h"
19  
20 #define ERR(fmt, args...) do { \
21 fflush(0); \
22 fprintf(stderr, "[%s] *** error: " fmt "\n", \
23 progname, ## args ); \
24 } while (0)
25  
26 static char *progname;
27 static char *ifname;
28 static char *ofname;
29 static char *crypt_key = "Buffalo";
30 static char *magic = "start";
31 static int longstate;
32 static unsigned char seed = 'O';
33  
34 static char *product;
35 static char *version;
36 static int do_decrypt;
37 static int offset;
38 static int size;
39  
40 void usage(int status)
41 {
42 FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
43  
44 fprintf(stream, "Usage: %s [OPTIONS...]\n", progname);
45 fprintf(stream,
46 "\n"
47 "Options:\n"
48 " -d decrypt instead of encrypt\n"
49 " -i <file> read input from the file <file>\n"
50 " -o <file> write output to the file <file>\n"
51 " -l use longstate {en,de}cryption method\n"
52 " -k <key> use <key> for encryption (default: Buffalo)\n"
53 " -m <magic> set magic to <magic>\n"
54 " -p <product> set product name to <product>\n"
55 " -v <version> set version to <version>\n"
56 " -h show this screen\n"
57 " -O Offset of encrypted data in file (decryption)\n"
58 " -S Size of unencrypted data in file (encryption)\n"
59 );
60  
61 exit(status);
62 }
63  
64 static int decrypt_file(void)
65 {
66 struct enc_param ep;
67 ssize_t src_len;
68 unsigned char *buf = NULL;
69 int err;
70 int ret = -1;
71  
72 src_len = get_file_size(ifname);
73 if (src_len < 0) {
74 ERR("unable to get size of '%s'", ifname);
75 goto out;
76 }
77  
78 buf = malloc(src_len);
79 if (buf == NULL) {
80 ERR("no memory for the buffer");
81 goto out;
82 }
83  
84 err = read_file_to_buf(ifname, buf, src_len);
85 if (err) {
86 ERR("unable to read from file '%s'", ifname);
87 goto out;
88 }
89  
90 memset(&ep, '\0', sizeof(ep));
91 ep.key = (unsigned char *) crypt_key;
92 ep.longstate = longstate;
93  
94 err = decrypt_buf(&ep, buf + offset, src_len - offset);
95 if (err) {
96 ERR("unable to decrypt '%s'", ifname);
97 goto out;
98 }
99  
100 printf("Magic\t\t: '%s'\n", ep.magic);
101 printf("Seed\t\t: 0x%02x\n", ep.seed);
102 printf("Product\t\t: '%s'\n", ep.product);
103 printf("Version\t\t: '%s'\n", ep.version);
104 printf("Data len\t: %u\n", ep.datalen);
105 printf("Checksum\t: 0x%08x\n", ep.csum);
106  
107 err = write_buf_to_file(ofname, buf + offset, ep.datalen);
108 if (err) {
109 ERR("unable to write to file '%s'", ofname);
110 goto out;
111 }
112  
113 ret = 0;
114  
115 out:
116 free(buf);
117 return ret;
118 }
119  
120 static int encrypt_file(void)
121 {
122 struct enc_param ep;
123 ssize_t src_len, tail_dst, tail_len, tail_src;
124 unsigned char *buf;
125 uint32_t hdrlen;
126 ssize_t totlen = 0;
127 int err;
128 int ret = -1;
129  
130 src_len = get_file_size(ifname);
131 if (src_len < 0) {
132 ERR("unable to get size of '%s'", ifname);
133 goto out;
134 }
135  
136 if (size) {
137 tail_dst = enc_compute_buf_len(product, version, size);
138 tail_len = src_len - size;
139 totlen = tail_dst + tail_len;
140 } else
141 totlen = enc_compute_buf_len(product, version, src_len);
142  
143 buf = malloc(totlen);
144 if (buf == NULL) {
145 ERR("no memory for the buffer");
146 goto out;
147 }
148  
149 hdrlen = enc_compute_header_len(product, version);
150  
151 err = read_file_to_buf(ifname, &buf[hdrlen], src_len);
152 if (err) {
153 ERR("unable to read from file '%s'", ofname);
154 goto free_buf;
155 }
156  
157 if (size) {
158 tail_src = hdrlen + size;
159 memmove(&buf[tail_dst], &buf[tail_src], tail_len);
160 memset(&buf[tail_src], 0, tail_dst - tail_src);
161 src_len = size;
162 }
163  
164 memset(&ep, '\0', sizeof(ep));
165 ep.key = (unsigned char *) crypt_key;
166 ep.seed = seed;
167 ep.longstate = longstate;
168 ep.csum = buffalo_csum(src_len, &buf[hdrlen], src_len);
169 ep.datalen = src_len;
170 strcpy((char *) ep.magic, magic);
171 strcpy((char *) ep.product, product);
172 strcpy((char *) ep.version, version);
173  
174 err = encrypt_buf(&ep, buf, &buf[hdrlen]);
175 if (err) {
176 ERR("invalid input file");
177 goto free_buf;
178 }
179  
180 err = write_buf_to_file(ofname, buf, totlen);
181 if (err) {
182 ERR("unable to write to file '%s'", ofname);
183 goto free_buf;
184 }
185  
186 ret = 0;
187  
188 free_buf:
189 free(buf);
190 out:
191 return ret;
192 }
193  
194 static int check_params(void)
195 {
196 int ret = -1;
197  
198 if (ifname == NULL) {
199 ERR("no input file specified");
200 goto out;
201 }
202  
203 if (ofname == NULL) {
204 ERR("no output file specified");
205 goto out;
206 }
207  
208 if (crypt_key == NULL) {
209 ERR("no key specified");
210 goto out;
211 } else if (strlen(crypt_key) > BCRYPT_MAX_KEYLEN) {
212 ERR("key '%s' is too long", crypt_key);
213 goto out;
214 }
215  
216 if (strlen(magic) != (ENC_MAGIC_LEN - 1)) {
217 ERR("length of magic must be %d", ENC_MAGIC_LEN - 1);
218 goto out;
219 }
220  
221 if (!do_decrypt) {
222 if (product == NULL) {
223 ERR("no product specified");
224 goto out;
225 }
226  
227 if (version == NULL) {
228 ERR("no version specified");
229 goto out;
230 }
231  
232 if (strlen(product) > (ENC_PRODUCT_LEN - 1)) {
233 ERR("product name '%s' is too long", product);
234 goto out;
235 }
236  
237 if (strlen(version) > (ENC_VERSION_LEN - 1)) {
238 ERR("version '%s' is too long", version);
239 goto out;
240 }
241 }
242  
243 ret = 0;
244  
245 out:
246 return ret;
247 }
248  
249 int main(int argc, char *argv[])
250 {
251 int res = EXIT_FAILURE;
252 int err;
253  
254 progname = basename(argv[0]);
255  
256 while ( 1 ) {
257 int c;
258  
259 c = getopt(argc, argv, "adi:m:o:hlp:v:k:O:r:s:S:");
260 if (c == -1)
261 break;
262  
263 switch (c) {
264 case 'd':
265 do_decrypt = 1;
266 break;
267 case 'i':
268 ifname = optarg;
269 break;
270 case 'l':
271 longstate = 1;
272 break;
273 case 'm':
274 magic = optarg;
275 break;
276 case 'o':
277 ofname = optarg;
278 break;
279 case 'p':
280 product = optarg;
281 break;
282 case 'v':
283 version = optarg;
284 break;
285 case 'k':
286 crypt_key = optarg;
287 break;
288 case 's':
289 seed = strtoul(optarg, NULL, 16);
290 break;
291 case 'O':
292 offset = strtoul(optarg, NULL, 0);
293 break;
294 case 'S':
295 size = strtoul(optarg, NULL, 0);
296 break;
297 case 'h':
298 usage(EXIT_SUCCESS);
299 break;
300 default:
301 usage(EXIT_FAILURE);
302 break;
303 }
304 }
305  
306 err = check_params();
307 if (err)
308 goto out;
309  
310 if (do_decrypt)
311 err = decrypt_file();
312 else
313 err = encrypt_file();
314  
315 if (err)
316 goto out;
317  
318 res = EXIT_SUCCESS;
319  
320 out:
321 return res;
322 }