cvs.zerfleddert.de Git - proxmark3-svn/blob

1 //-----------------------------------------------------------------------------

3 //

4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,

5 // at your option, any later version. See the LICENSE.txt file for the text of

6 // the license.

7 //-----------------------------------------------------------------------------

8 // Tools for work with CBOR format http://cbor.io/spec.html

9 // via Intel tinycbor (https://github.com/intel/tinycbor) library

10 //-----------------------------------------------------------------------------

11 //

13 #include "cbortools.h"

15 #include <stdlib.h>

16 #include <inttypes.h>

18 #include "emv/emvjson.h"

19 #include "util.h"

20 #include "fidocore.h"

 static void indent(int nestingLevel) {

23 while (nestingLevel--)

24 printf(" ");

25 }

 static CborError dumpelm(CborValue *it, bool *got_next, int nestingLevel) {

28 CborError err;

29 *got_next = false;

31 CborType type = cbor_value_get_type(it);

32 indent(nestingLevel);

33 switch (type) {

34 case CborMapType:

35 case CborArrayType: {

                 printf(type == CborArrayType ? "Array[" : "Map[");

37 break;

38 }

40 case CborIntegerType: {

41 int64_t val;

                 cbor_value_get_int64(it, &val);     // can't fail

                 printf("%" PRIi64, val);

44 break;

45 }

47 case CborByteStringType: {

48 uint8_t *buf;

49 size_t n;

                 err = cbor_value_dup_byte_string(it, &buf, &n, it);

51 *got_next = true;

52 if (err)

53 return err; // parse error

                 printf("%s", sprint_hex(buf, n));

55 free(buf);

56 break;

57 }

59 case CborTextStringType: {

60 char *buf;

61 size_t n;

                 err = cbor_value_dup_text_string(it, &buf, &n, it);

63 *got_next = true;

64 if (err)

65 return err; // parse error

                 printf("%s", buf);

67 free(buf);

68 break;

69 }

71 case CborTagType: {

72 CborTag tag;

73 cbor_value_get_tag(it, &tag);

                 printf("Tag(%" PRIu64, tag);

75 break;

76 }

78 case CborSimpleType: {

79 uint8_t type;

80 cbor_value_get_simple_type(it, &type);

                 printf("simple(%u)", type);

82 break;

83 }

85 case CborNullType:

86 printf("null");

87 break;

89 case CborUndefinedType:

90 printf("undefined");

91 break;

93 case CborBooleanType: {

94 bool val;

                 cbor_value_get_boolean(it, &val);       // can't fail

                 printf("%s", val ? "true" : "false");

97 break;

98 }

100 case CborDoubleType: {

101 double val;

102 if (false) {

103 float f;

104 case CborFloatType:

105 cbor_value_get_float(it, &f);

106 val = f;

107 } else {

108 cbor_value_get_double(it, &val);

109 }

                 printf("%g", val);

111 break;

112 }

113 case CborHalfFloatType: {

114 uint16_t val;

115 cbor_value_get_half_float(it, &val);

                 printf("__f16(%04x)", val);

117 break;

118 }

119

120 case CborInvalidType:

121 printf("CborInvalidType!!!");

122 break;

123 }

124

125 return CborNoError;

126 }

127

 static CborError dumprecursive(uint8_t cmdCode, bool isResponse, CborValue *it, bool isMapType, int nestingLevel) {

129 int elmCount = 0;

         while (!cbor_value_at_end(it)) {

131 CborError err;

132 CborType type = cbor_value_get_type(it);

133 //printf("^%x^", type);

134 bool got_next;

135

136 switch (type) {

137 case CborMapType:

138 case CborArrayType: {

139 // recursive type

140 CborValue recursed;

                         assert(cbor_value_is_container(it));

                         if (!(isMapType && (elmCount % 2)))

143 indent(nestingLevel);

                         printf(type == CborArrayType ? "Array[\n" : "Map[\n");

                         err = cbor_value_enter_container(it, &recursed);

146 if (err)

147 return err; // parse error

                         err = dumprecursive(cmdCode, isResponse, &recursed, (type == CborMapType), nestingLevel + 1);

149 if (err)

150 return err; // parse error

                         err = cbor_value_leave_container(it, &recursed);

152 if (err)

153 return err; // parse error

154 indent(nestingLevel);

155 printf("]");

156 got_next = true;

157 break;

158 }

159

160 default: {

                         err = dumpelm(it, &got_next, (isMapType && (elmCount % 2)) ? 0 : nestingLevel);

162 if (err)

163 return err;

                         if (cmdCode > 0 && nestingLevel == 1 && isMapType && !(elmCount % 2)) {

165 int64_t val;

166 cbor_value_get_int64(it, &val);

                                 char *desc = fido2GetCmdMemberDescription(cmdCode, isResponse, val);

168 if (desc)

                                         printf(" (%s)", desc);

170 }

171 break;

172 }

173 }

174

175 if (!got_next) {

176 err = cbor_value_advance_fixed(it);

177 if (err)

178 return err;

179 }

                 if (isMapType && !(elmCount % 2)) {

181 printf(": ");

182 } else {

                         printf("\n");

184 }

185 elmCount++;

186 }

187 return CborNoError;

188 }

189

 int TinyCborInit(uint8_t *data, size_t length, CborValue *cb) {

191 CborParser parser;

         CborError err = cbor_parser_init(data, length, 0, &parser, cb);

193 if (err)

194 return err;

195

196 return 0;

197 }

198

 int TinyCborPrintFIDOPackage(uint8_t cmdCode, bool isResponse, uint8_t *data, size_t length) {

200 CborValue cb;

201 int res;

         res = TinyCborInit(data, length, &cb);

203 if (res)

204 return res;

205

     CborError err = dumprecursive(cmdCode, isResponse, &cb, false, 0);

207

208 if (err) {

                 fprintf(stderr, "CBOR parsing failure at offset %td : %s\n", cb.ptr - data, cbor_error_string(err));

210 return 1;

211 }

212

213 return 0;

214 }

215

 int JsonObjElmCount(json_t *elm) {

217 int res = 0;

218 const char *key;

219 json_t *value;

220

         if (!json_is_object(elm))

222 return 0;

223

         json_object_foreach(elm, key, value) {

                 if (strlen(key) > 0 && key[0] != '.')

226 res++;

227 }

228

229 return res;

230 }

231

 int JsonToCbor(json_t *elm, CborEncoder *encoder) {

233 if (!elm || !encoder)

234 return 1;

235

236 int res;

237

238 // CBOR map == JSON object

         if (json_is_object(elm)) {

240 CborEncoder map;

241 const char *key;

242 json_t *value;

243

                 res = cbor_encoder_create_map(encoder, &map, JsonObjElmCount(elm));

245 cbor_check(res);

246

                 json_object_foreach(elm, key, value) {

                         if (strlen(key) > 0 && key[0] != '.') {

                                 res = cbor_encode_text_stringz(&map, key);              

250 cbor_check(res);

251

252 // RECURSION!

253 JsonToCbor(value, &map);

254 }

255 }

256

                 res = cbor_encoder_close_container(encoder, &map);

258 cbor_check(res);

259 }

260

261 // CBOR array == JSON array

         if (json_is_array(elm)) {

263 size_t index;

264 json_t *value;

265 CborEncoder array;

266

                 res = cbor_encoder_create_array(encoder, &array, json_array_size(elm));

268 cbor_check(res);

269

                 json_array_foreach(elm, index, value) {

271 // RECURSION!

272 JsonToCbor(value, &array);

273 }

274

                 res = cbor_encoder_close_container(encoder, &array);

276 cbor_check(res);

277 }

278

         if (json_is_boolean(elm)) {

                 res = cbor_encode_boolean(encoder, json_is_true(elm));

281 cbor_check(res);

282 }

283

         if (json_is_integer(elm)) {

                 res = cbor_encode_int(encoder, json_integer_value(elm));

286 cbor_check(res);

287 }

288

         if (json_is_real(elm)) {

                 res = cbor_encode_float(encoder, json_real_value(elm));

291 cbor_check(res);

292 }

293

         if (json_is_string(elm)) {

                 const char * val = json_string_value(elm);

                 if (CheckStringIsHEXValue(val)) {

297 size_t datalen = 0;

                         uint8_t data[4096] = {0};

                         res = JsonLoadBufAsHex(elm, "$", data, sizeof(data), &datalen);

300 if (res)

301 return 100;

302

                         res = cbor_encode_byte_string(encoder, data, datalen);

304 cbor_check(res);

305 } else {

                         res = cbor_encode_text_stringz(encoder, val);

307 cbor_check(res);

308 }

309 }

310

311

312

313 return 0;

314 }

315

 int CborMapGetKeyById(CborParser *parser, CborValue *map, uint8_t *data, size_t dataLen, int key) {

317 CborValue cb;

318

         CborError err = cbor_parser_init(data, dataLen, 0, parser, &cb);

320 cbor_check(err);

321

         if (cbor_value_get_type(&cb) != CborMapType)

323 return 1;

324

         err = cbor_value_enter_container(&cb, map);

326 cbor_check(err);

327

328 int64_t indx;

         while (!cbor_value_at_end(map)) {

330 // check number

                 if (cbor_value_get_type(map) != CborIntegerType)

332 return 1;

333

334 cbor_value_get_int64(map, &indx);

335

336 err = cbor_value_advance(map);

337 cbor_check(err);

338

339 if (indx == key)

340 return 0;

341

342 // pass value

343 err = cbor_value_advance(map);

344 cbor_check(err);

345 }

346

         err = cbor_value_leave_container(&cb, map);

348 cbor_check(err);

349

350 return 2;

351 }

352

 CborError CborGetArrayBinStringValue(CborValue *elm, uint8_t *data, size_t maxdatalen, size_t *datalen) {

         return CborGetArrayBinStringValueEx(elm, data, maxdatalen, datalen, NULL, 0);

355 }

356

 CborError CborGetArrayBinStringValueEx(CborValue *elm, uint8_t *data, size_t maxdatalen, size_t *datalen, uint8_t *delimeter, size_t delimeterlen) {

358 CborValue array;

359 if (datalen)

360 *datalen = 0;

361

362 size_t slen = maxdatalen;

363 size_t totallen = 0;

364

         CborError res = cbor_value_enter_container(elm, &array);

366 cbor_check(res);

367

         while (!cbor_value_at_end(&array)) {

                 res = cbor_value_copy_byte_string(&array, &data[totallen], &slen, &array);

370 cbor_check(res);

371

372 totallen += slen;

373 if (delimeter) {

                         memcpy(&data[totallen], delimeter, delimeterlen);

375 totallen += delimeterlen;

376 }

377 slen = maxdatalen - totallen;

378 }

379

         res = cbor_value_leave_container(elm, &array);

381 cbor_check(res);

382

383 if (datalen)

384 *datalen = totallen;

385

386 return CborNoError;

387 };

388

 CborError CborGetBinStringValue(CborValue *elm, uint8_t *data, size_t maxdatalen, size_t *datalen) {

390 if (datalen)

391 *datalen = 0;

392

393 size_t slen = maxdatalen;

394

         CborError res = cbor_value_copy_byte_string(elm, data, &slen, elm);

396 cbor_check(res);

397

398 if (datalen)

399 *datalen = slen;

400

401 return CborNoError;

402 };

403

 CborError CborGetArrayStringValue(CborValue *elm, char *data, size_t maxdatalen, size_t *datalen, char *delimeter) {

405 CborValue array;

406 if (datalen)

407 *datalen = 0;

408

409 size_t slen = maxdatalen;

410 size_t totallen = 0;

411

         CborError res = cbor_value_enter_container(elm, &array);

413 cbor_check(res);

414

         while (!cbor_value_at_end(&array)) {

                 res = cbor_value_copy_text_string(&array, &data[totallen], &slen, &array);

417 cbor_check(res);

418

419 totallen += slen;

420 if (delimeter) {

421 strcat(data, delimeter);

422 totallen += strlen(delimeter);

423 }

424 slen = maxdatalen - totallen;

425 data[totallen] = 0x00;

426 }

427

         res = cbor_value_leave_container(elm, &array);

429 cbor_check(res);

430

431 if (datalen)

432 *datalen = totallen;

433

434 return CborNoError;

435 };

436

 CborError CborGetStringValue(CborValue *elm, char *data, size_t maxdatalen, size_t *datalen) {

438 if (datalen)

439 *datalen = 0;

440

441 size_t slen = maxdatalen;

442

         CborError res = cbor_value_copy_text_string(elm, data, &slen, elm);

444 cbor_check(res);

445

446 if (datalen)

447 *datalen = slen;

448

449 return CborNoError;

450 };

451

452 CborError CborGetStringValueBuf(CborValue *elm) {

453 static char stringBuf[2048];

         memset(stringBuf, 0x00, sizeof(stringBuf));

455

         return CborGetStringValue(elm, stringBuf, sizeof(stringBuf), NULL);

457 };

458

 int CBOREncodeElm(json_t *root, char *rootElmId, CborEncoder *encoder) {

460 json_t *elm = NULL;

         if (rootElmId && strlen(rootElmId) && rootElmId[0] == '$')

                 elm = json_path_get(root, rootElmId);

463 else

                 elm = json_object_get(root, rootElmId);

465

466 if (!elm)

467 return 1;

468

         int res = JsonToCbor(elm, encoder);

470

471 return res;

472 }

473

 CborError CBOREncodeClientDataHash(json_t *root, CborEncoder *encoder) {

         uint8_t buf[100] = {0};

476 size_t jlen;

477

         JsonLoadBufAsHex(root, "$.ClientDataHash", buf, sizeof(buf), &jlen);

479

480 // fill with 0x00 if not found

481 if (!jlen)

482 jlen = 32;

483

         int res = cbor_encode_byte_string(encoder, buf, jlen);

485 cbor_check(res);

486

487 return 0;

488 }