diff --git a/Makefile.am b/Makefile.am
index 938cfd9..2ac28b2 100644
--- a/Makefile.am
+++ b/Makefile.am
ell/main.h \
ell/strv.h \
ell/string.h \
+ ell/utf8.h \
ell/dbus.h \
ell/dbus-service.h \
ell/dbus-client.h
ell/string.c \
ell/cipher.c \
ell/checksum.c \
+ ell/utf8.c \
ell/dbus-private.h \
ell/dbus.c \
ell/dbus-message.c \
$(GLIB_LIBS) $(ALSA_LIBS)
endif
+unit_tests += unit/test-mesh-crypto
+unit_test_mesh_crypto_CPPFLAGS = $(ell_cflags)
+unit_test_mesh_crypto_SOURCES = unit/test-mesh-crypto.c \
+ mesh/crypto.h ell/internal ell/ell.h \
+ $(ell_sources)
+unit_test_mesh_crypto_LDADD = src/libshared-ell.la \
+ $(ell_ldadd)
+
if MAINTAINER_MODE
noinst_PROGRAMS += $(unit_tests)
endif
diff --git a/unit/test-mesh-crypto.c b/unit/test-mesh-crypto.c
new file mode 100644
index 0000000..6acb9c0
--- /dev/null
+++ b/unit/test-mesh-crypto.c
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2019 Intel Corporation. All rights reserved.
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "client/display.h"
+
+#include "mesh/crypto.c"
+
+struct mesh_crypto_test {
+ const char *name;
+
+ const char *dev_key;
+ const char *app_key;
+ const char *net_key;
+ const char *uuid;
+ uint32_t iv_index;
+
+ uint8_t net_nid;
+ uint8_t key_aid;
+ bool md[32];
+ bool szmic;
+ bool frnd;
+ bool ctl;
+ bool segmented;
+ bool relay;
+ bool akf;
+ bool kr;
+ bool ivu;
+ bool network_only;
+ uint8_t seg_max;
+ uint8_t seg_num;
+ uint8_t opcode;
+ uint8_t net_ttl;
+ uint16_t seqZero;
+ uint32_t app_seq;
+ uint32_t net_seq[32];
+ uint16_t net_src;
+ uint16_t net_dst;
+ const char *app_msg;
+
+ const char *ikm;
+ const char *okm;
+ const char *info;
+ const char *salt;
+ const char *salt_out;
+ const char *nid;
+ const char *lpn_addr;
+ const char *lpn_cntr;
+ const char *fn_addr;
+ const char *fn_cntr;
+ const char *p;
+ const char *short_net_id;
+ const char *net_key_id;
+ const char *aid;
+
+ const char *enc_key;
+ const char *net_id;
+ const char *net_nonce[32];
+ const char *app_nonce;
+ const char *priv_key;
+ const char *priv_rand[32];
+
+ const char *enc_msg;
+ uint32_t app_mic32;
+ uint64_t app_mic64;
+
+ const char *trans_pkt[32];
+ const char *net_msg[32];
+ uint32_t net_mic32[32];
+ uint64_t net_mic64;
+
+ const char *packet[32];
+
+ uint8_t beacon_type;
+ uint8_t beacon_flags;
+ const char *beacon_cmac;
+ const char *beacon;
+
+ const char *rand;
+ const char *ident_res_key;
+ const char *hash_input;
+ const char *mesh_id_hash;
+ const char *identity_hash;
+};
+
+static const struct mesh_crypto_test s8_1_1 = {
+ .name = "8.1.1 s1 SALT generation function",
+ .salt = "test",
+ .salt_out = "b73cefbd641ef2ea598c2b6efb62f79c",
+};
+
+static const struct mesh_crypto_test s8_1_2 = {
+ .name = "8.1.2 k1 function",
+ .ikm = "3216d1509884b533248541792b877f98",
+ .salt = "salt",
+ .info = "info",
+ .okm = "f6ed15a8934afbe7d83e8dcb57fcf5d7",
+};
+
+static const struct mesh_crypto_test s8_1_3 = {
+ .name = "8.1.3 k2 function (master)",
+ .net_key = "f7a2a44f8e8a8029064f173ddc1e2b00",
+ .p = "00",
+ .nid = "7f",
+ .enc_key = "9f589181a0f50de73c8070c7a6d27f46",
+ .priv_key = "4c715bd4a64b938f99b453351653124f",
+};
+
+static const struct mesh_crypto_test s8_1_4 = {
+ .name = "8.1.4 k2 function (friendship)",
+ .frnd = true,
+ .lpn_addr = "0203",
+ .fn_addr = "0405",
+ .lpn_cntr = "0607",
+ .fn_cntr = "0809",
+ .net_key = "f7a2a44f8e8a8029064f173ddc1e2b00",
+ .p = "010203040506070809",
+ .nid = "73",
+ .enc_key = "11efec0642774992510fb5929646df49",
+ .priv_key = "d4d7cc0dfa772d836a8df9df5510d7a7",
+};
+
+static const struct mesh_crypto_test s8_1_5 = {
+ .name = "8.1.5 k3 function",
+ .net_key = "f7a2a44f8e8a8029064f173ddc1e2b00",
+ .salt = "smk3",
+ .info = "id64\01",
+ .short_net_id = "ff046958233db014",
+};
+
+static const struct mesh_crypto_test s8_1_6 = {
+ .name = "8.1.6 k4 function",
+ .app_key = "3216d1509884b533248541792b877f98",
+ .salt = "smk4",
+ .info = "id6\01",
+ .aid = "38",
+};
+
+
+static const struct mesh_crypto_test s8_2_1 = {
+ .name = "8.2.1 Application key AID",
+ .app_key = "63964771734fbd76e3b40519d1d94a48",
+ .salt = "smk4",
+ .info = "id6\01",
+ .aid = "26",
+};
+
+static const struct mesh_crypto_test s8_2_2 = {
+ .name = "8.2.2 Encryption and privacy keys (Master)",
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .p = "00",
+ .nid = "68",
+ .enc_key = "0953fa93e7caac9638f58820220a398e",
+ .priv_key = "8b84eedec100067d670971dd2aa700cf",
+};
+
+static const struct mesh_crypto_test s8_2_3 = {
+ .name = "8.2.3 Encryption and privacy keys (Friendship)",
+ .frnd = true,
+ .lpn_addr = "1201",
+ .fn_addr = "2345",
+ .lpn_cntr = "0000",
+ .fn_cntr = "072f",
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .p = "01120123450000072f",
+ .nid = "5e",
+ .enc_key = "be635105434859f484fc798e043ce40e",
+ .priv_key = "5d396d4b54d3cbafe943e051fe9a4eb8",
+};
+
+static const struct mesh_crypto_test s8_2_4 = {
+ .name = "8.2.4 Network ID",
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .salt = "smk3",
+ .info = "id64\01",
+ .short_net_id = "3ecaff672f673370",
+};
+
+static const struct mesh_crypto_test s8_2_5 = {
+ .name = "8.2.5 Identity Key",
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .salt = "nkik",
+ .info = "id128\01",
+ .enc_key = "84396c435ac48560b5965385253e210c",
+};
+
+static const struct mesh_crypto_test s8_2_6 = {
+ .name = "8.2.6 Beacon Key",
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .salt = "nkbk",
+ .info = "id128\01",
+ .enc_key = "5423d967da639a99cb02231a83f7d254",
+};
+
+static const struct mesh_crypto_test s8_3_1 = {
+ .name = "8.3.1 Message #1",
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .iv_index = 0x12345678,
+
+ .net_ttl = 0x00,
+ .net_seq = {0x000001},
+ .net_src = 0x1201,
+ .net_dst = 0xfffd,
+ .opcode = NET_OP_FRND_REQUEST,
+ .trans_pkt = {"034b50057e400000010000"},
+ .net_nid = 0x68,
+
+
+ .ctl = true,
+ .enc_key = "0953fa93e7caac9638f58820220a398e",
+ .net_nonce = {"00800000011201000012345678"},
+ .priv_key = "8b84eedec100067d670971dd2aa700cf",
+ .priv_rand = {"000000000012345678b5e5bfdacbaf6c"},
+
+ .net_msg = {"b5e5bfdacbaf6cb7fb6bff871f"},
+ .net_mic64 = 0x035444ce83a670df,
+
+ .packet = {"68eca487516765b5e5bfdacbaf6cb7fb6bff871f035444ce83a670df"},
+};
+
+static const struct mesh_crypto_test s8_3_2 = {
+ .name = "8.3.2 Message #2",
+
+ .iv_index = 0x12345678,
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+
+ .ctl = true,
+ .net_ttl = 0x00,
+ .net_seq = {0x014820},
+ .net_src = 0x2345,
+ .net_dst = 0x1201,
+ .trans_pkt = {"04320308ba072f"},
+ .net_nid = 0x68,
+
+
+ .opcode = NET_OP_FRND_OFFER,
+ .enc_key = "0953fa93e7caac9638f58820220a398e",
+ .net_nonce = {"00800148202345000012345678"},
+ .priv_key = "8b84eedec100067d670971dd2aa700cf",
+
+ .net_msg = {"79d7dbc0c9b4d43eeb"},
+ .net_mic64 = 0xec129d20a620d01e,
+
+ .priv_rand = {"00000000001234567879d7dbc0c9b4d4"},
+ .packet = {"68d4c826296d7979d7dbc0c9b4d43eebec129d20a620d01e"},
+};
+
+static const struct mesh_crypto_test s8_3_3 = {
+ .name = "8.3.3 Message #3",
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .iv_index = 0x12345678,
+
+ .ctl = true,
+ .net_ttl = 0x00,
+ .net_seq = {0x2b3832},
+ .net_dst = 0x1201,
+ .net_src = 0x2fe3,
+ .trans_pkt = {"04fa0205a6000a"},
+ .net_nid = 0x68,
+
+
+ .opcode = NET_OP_FRND_OFFER,
+ .enc_key = "0953fa93e7caac9638f58820220a398e",
+ .net_nonce = {"00802b38322fe3000012345678"},
+ .priv_key = "8b84eedec100067d670971dd2aa700cf",
+ .priv_rand = {"00000000001234567853273086b8c5ee"},
+
+ .net_msg = {"53273086b8c5ee00bd"},
+ .net_mic64 = 0xd9cfcc62a2ddf572,
+
+ .packet = {"68da062bc96df253273086b8c5ee00bdd9cfcc62a2ddf572"},
+};
+
+static const struct mesh_crypto_test s8_3_4 = {
+ .name = "8.3.4 Message #4",
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .iv_index = 0x12345678,
+
+ .net_nid = 0x5e,
+ .net_ttl = 0x00,
+ .net_seq = {0x000002},
+ .net_dst = 0x2345,
+ .net_src = 0x1201,
+ .trans_pkt = {"0100"},
+
+ .frnd = true,
+ .lpn_addr = "1201",
+ .fn_addr = "2345",
+ .lpn_cntr = "0000",
+ .fn_cntr = "072f",
+ .p = "01120123450000072f",
+
+ .ctl = true,
+ .opcode = NET_OP_FRND_POLL,
+ .enc_key = "be635105434859f484fc798e043ce40e",
+ .net_nonce = {"00800000021201000012345678"},
+ .priv_key = "5d396d4b54d3cbafe943e051fe9a4eb8",
+ .priv_rand = {"000000000012345678b0e5d0ad970d57"},
+
+ .net_msg = {"b0e5d0ad"},
+ .net_mic64 = 0x970d579a4e88051c,
+
+ .packet = {"5e84eba092380fb0e5d0ad970d579a4e88051c"},
+};
+
+static const struct mesh_crypto_test s8_3_5 = {
+ .name = "8.3.5 Message #5",
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .iv_index = 0x12345678,
+
+ .net_nid = 0x5e,
+ .net_ttl = 0x00,
+ .net_seq = {0x014834},
+ .net_src = 0x2345,
+ .net_dst = 0x1201,
+ .trans_pkt = {"02001234567800"},
+
+ .frnd = true,
+ .lpn_addr = "1201",
+ .fn_addr = "2345",
+ .lpn_cntr = "0000",
+ .fn_cntr = "072f",
+ .p = "01120123450000072f",
+
+ .ctl = true,
+ .opcode = NET_OP_FRND_UPDATE,
+ .enc_key = "be635105434859f484fc798e043ce40e",
+ .net_nonce = {"00800148342345000012345678"},
+ .priv_key = "5d396d4b54d3cbafe943e051fe9a4eb8",
+ .priv_rand = {"0000000000123456785c39da1792b1fe"},
+
+ .net_msg = {"5c39da1792b1fee9ec"},
+ .net_mic64 = 0x74b786c56d3a9dee,
+
+ .packet = {"5eafd6f53c43db5c39da1792b1fee9ec74b786c56d3a9dee"},
+};
+
+static const struct mesh_crypto_test s8_3_6 = {
+ .name = "8.3.6 Message #6",
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .dev_key = "9d6dd0e96eb25dc19a40ed9914f8f03f",
+ .iv_index = 0x12345678,
+
+ .segmented = true,
+ .net_nid = 0x68,
+ .net_ttl = 0x04,
+ .app_seq = 0x3129ab,
+ .net_seq = {0x3129ab,
+ 0x3129ac},
+ .net_src = 0x0003,
+ .net_dst = 0x1201,
+ .app_msg = "0056341263964771734fbd76e3b40519d1d94a48",
+ .enc_msg = "ee9dddfd2169326d23f3afdfcfdc18c52fdef772",
+ .app_mic32 = 0xe0e17308,
+
+ .enc_key = "0953fa93e7caac9638f58820220a398e",
+ .app_nonce = "02003129ab0003120112345678",
+
+ .priv_key = "8b84eedec100067d670971dd2aa700cf",
+
+ .net_nonce = {"00043129ab0003000012345678",
+ "00043129ac0003000012345678"},
+
+ .priv_rand = {"0000000000123456780afba8c63d4e68",
+ "0000000000123456786cae0c032bf074"},
+
+ .trans_pkt = {"8026ac01ee9dddfd2169326d23f3afdf",
+ "8026ac21cfdc18c52fdef772e0e17308"},
+
+ .net_msg = {"0afba8c63d4e686364979deaf4fd40961145",
+ "6cae0c032bf0746f44f1b8cc8ce5edc57e55"},
+
+ .net_mic32 = {0x939cda0e,
+ 0xbeed49c0},
+
+ .packet = {"68cab5c5348a230afba8c63d4e686364979deaf4fd40961145939cda0e",
+ "681615b5dd4a846cae0c032bf0746f44f1b8cc8ce5edc57e55beed49c0"},
+};
+
+static const struct mesh_crypto_test s8_3_7 = {
+ .name = "8.3.7 Message #7",
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .iv_index = 0x12345678,
+
+ .net_nid = 0x68,
+ .relay = true,
+ .ctl = true,
+ .net_ttl = 0x0b,
+ .net_seq = {0x014835},
+ .net_src = 0x2345,
+ .net_dst = 0x0003,
+ .opcode = NET_OP_SEG_ACKNOWLEDGE,
+ .seqZero = 0x09ab,
+ .trans_pkt = {"00a6ac00000002"},
+
+
+ .enc_key = "0953fa93e7caac9638f58820220a398e",
+ .net_nonce = {"008b0148352345000012345678"},
+ .priv_key = "8b84eedec100067d670971dd2aa700cf",
+ .priv_rand = {"0000000000123456780d0d730f94d7f3"},
+
+ .net_msg = {"0d0d730f94d7f3509d"},
+ .net_mic64 = 0xf987bb417eb7c05f,
+
+ .packet = {"68e476b5579c980d0d730f94d7f3509df987bb417eb7c05f"},
+};
+
+static const struct mesh_crypto_test s8_3_8 = {
+ .name = "8.3.8 Message #8",
+ .network_only = true, /* Test has incomplete Access Payload */
+ .seg_max = 1,
+ .seg_num = 0,
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .iv_index = 0x12345678,
+
+ .net_nid = 0x68,
+ .relay = true,
+ .net_ttl = 0x04,
+ .net_seq = {0x3129ad},
+ .net_src = 0x0003,
+ .net_dst = 0x1201,
+ .segmented = true,
+ .seqZero = 0x09ab,
+ .trans_pkt = {"8026ac01ee9dddfd2169326d23f3afdf"},
+
+
+ .enc_key = "0953fa93e7caac9638f58820220a398e",
+ .net_nonce = {"00043129ad0003000012345678"},
+ .priv_key = "8b84eedec100067d670971dd2aa700cf",
+ .priv_rand = {"0000000000123456780e2f91add6f06e"},
+
+ .net_msg = {"0e2f91add6f06e66006844cec97f973105ae"},
+ .net_mic32 = {0x2534f958},
+
+ .packet = {"684daa6267c2cf0e2f91add6f06e66006844cec97f973105ae2534f958"},
+};
+
+
+static const struct mesh_crypto_test s8_3_9 = {
+ .name = "8.3.9 Message #9",
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .iv_index = 0x12345678,
+
+ .net_nid = 0x68,
+ .relay = true,
+ .ctl = true,
+ .net_ttl = 0x0b,
+ .net_seq = {0x014836},
+ .net_src = 0x2345,
+ .net_dst = 0x0003,
+ .opcode = NET_OP_SEG_ACKNOWLEDGE,
+ .seqZero = 0x09ab,
+ .trans_pkt = {"00a6ac00000003"},
+
+
+ .enc_key = "0953fa93e7caac9638f58820220a398e",
+ .net_nonce = {"008b0148362345000012345678"},
+ .priv_key = "8b84eedec100067d670971dd2aa700cf",
+ .priv_rand = {"000000000012345678d85d806bbed248"},
+
+ .net_msg = {"d85d806bbed248614f"},
+ .net_mic64 = 0x938067b0d983bb7b,
+
+ .packet = {"68aec467ed4901d85d806bbed248614f938067b0d983bb7b"},
+};
+
+static const struct mesh_crypto_test s8_3_10 = {
+ .name = "8.3.10 Message #10",
+
+ .iv_index = 0x12345678,
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+
+ .net_nid = 0x5e,
+ .net_ttl = 0x00,
+ .net_seq = {0x000003},
+ .net_src = 0x1201,
+ .net_dst = 0x2345,
+ .trans_pkt = {"0101"},
+
+ .frnd = true,
+ .lpn_addr = "1201",
+ .fn_addr = "2345",
+ .lpn_cntr = "0000",
+ .fn_cntr = "072f",
+ .p = "01120123450000072f",
+
+ .ctl = true,
+ .opcode = NET_OP_FRND_POLL,
+ .enc_key = "be635105434859f484fc798e043ce40e",
+ .net_nonce = {"00800000031201000012345678"},
+ .priv_key = "5d396d4b54d3cbafe943e051fe9a4eb8",
+ .priv_rand = {"0000000000123456787777ed355afaf6"},
+
+ .net_msg = {"7777ed35"},
+ .net_mic64 = 0x5afaf66d899c1e3d,
+
+ .packet = {"5e7b786568759f7777ed355afaf66d899c1e3d"},
+};
+
+static const struct mesh_crypto_test s8_3_11 = {
+ .name = "8.3.11 Message #11",
+
+ /* Test has incomplete Access Payload */
+ .network_only = true,
+ .seg_max = 1,
+ .seg_num = 0,
+
+ .frnd = true,
+ .lpn_addr = "1201",
+ .fn_addr = "2345",
+ .lpn_cntr = "0000",
+ .fn_cntr = "072f",
+ .p = "01120123450000072f",
+
+ .iv_index = 0x12345678,
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+
+ .net_nid = 0x5e,
+ .net_ttl = 0x03,
+ .net_seq = {0x3129ad},
+ .net_src = 0x0003,
+ .net_dst = 0x1201,
+ .akf = true,
+ .key_aid = 0x00,
+ .segmented = true,
+ .seqZero = 0x09ab,
+ .trans_pkt = {"c026ac01ee9dddfd2169326d23f3afdf"},
+
+ .enc_key = "be635105434859f484fc798e043ce40e",
+ .net_nonce = {"00033129ad0003000012345678"},
+ .priv_key = "5d396d4b54d3cbafe943e051fe9a4eb8",
+ .priv_rand = {"000000000012345678d5e748a20ecfd9"},
+
+ .net_msg = {"d5e748a20ecfd98ddfd32de80befb400213d"},
+ .net_mic32 = {0x113813b5},
+
+ .packet = {"5e6ebfc021edf5d5e748a20ecfd98ddfd32de80befb400213d113813b5"},
+};
+
+static const struct mesh_crypto_test s8_4_3 = {
+ .name = "8.4.3 Secure Network Beacon",
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .iv_index = 0x12345678,
+
+ .enc_key = "5423d967da639a99cb02231a83f7d254",
+ .net_id = "3ecaff672f673370",
+
+ .beacon_type = 0x01,
+ .beacon_flags = 0x00,
+ .beacon_cmac = "8ea261582f364f6f",
+ .beacon = "01003ecaff672f673370123456788ea261582f364f6f",
+};
+
+static const struct mesh_crypto_test s8_6_2 = {
+ .name = "8.6.2 Service Data using Node Identity",
+
+ .net_key = "7dd7364cd842ad18c17c2b820c84c3d6",
+ .net_src = 0x1201,
+ .rand = "34ae608fbbc1f2c6",
+ .ident_res_key = "84396c435ac48560b5965385253e210c",
+
+ .hash_input = "00000000000034ae608fbbc1f2c61201",
+ .identity_hash = "00861765aefcc57b",
+ .beacon = "0100861765aefcc57b34ae608fbbc1f2c6",
+};
+
+#define PASS COLOR_GREEN "PASS" COLOR_OFF
+#define FAIL COLOR_RED "FAIL" COLOR_OFF
+#define INVAL COLOR_YELLOW "INVALID" COLOR_OFF
+
+#define EVALCMP(a, b, l) memcmp((a), (b), (l)) ? FAIL : PASS
+#define EVALSTR(a, b) (a) && (b) ? (strcmp((a), (b)) ? FAIL : PASS) : INVAL
+#define EVALNUM(a, b) a == b ? PASS : FAIL
+#define EVALBOOLNOTBOTH(a, b) !(a && b) ? PASS : FAIL
+
+static void verify_data(const char *label, unsigned int indent,
+ const char *sample, const uint8_t *data, size_t size)
+{
+ char *str;
+
+ str = l_util_hexstring(data, size);
+ l_info("%-20s =%*c%s", label, 1 + (indent * 2), ' ', sample);
+ l_info("%-20s %*c%s => %s", "", 1 + (indent * 2), ' ', str,
+ EVALSTR(sample, str));
+ l_free(str);
+}
+
+static void verify_bool_not_both(const char *label, unsigned int indent,
+ bool sample, bool data)
+{
+ l_info("%-20s =%*c%s", label, 1 + (indent * 2), ' ',
+ sample ? "true" : "false");
+ l_info("%-20s %*c%s => %s", "", 1 + (indent * 2), ' ',
+ data ? "true" : "false",
+ EVALBOOLNOTBOTH(sample, data));
+}
+
+static void verify_uint8(const char *label, unsigned int indent,
+ uint8_t sample, uint8_t data)
+{
+ l_info("%-20s =%*c%02x", label, 1 + (indent * 2), ' ', sample);
+ l_info("%-20s %*c%02x => %s", "", 1 + (indent * 2), ' ', data,
+ EVALNUM(sample, data));
+}
+
+static void verify_uint16(const char *label, unsigned int indent,
+ uint16_t sample, uint16_t data)
+{
+ l_info("%-20s =%*c%04x", label, 1 + (indent * 2), ' ', sample);
+ l_info("%-20s %*c%04x => %s", "", 1 + (indent * 2), ' ', data,
+ EVALNUM(sample, data));
+}
+
+static void verify_uint24(const char *label, unsigned int indent,
+ uint32_t sample, uint32_t data)
+{
+ l_info("%-20s =%*c%06x", label, 1 + (indent * 2), ' ', sample);
+ l_info("%-20s %*c%06x => %s", "", 1 + (indent * 2), ' ', data,
+ EVALNUM(sample, data));
+}
+
+static void verify_uint32(const char *label, unsigned int indent,
+ uint32_t sample, uint32_t data)
+{
+ l_info("%-20s =%*c%08x", label, 1 + (indent * 2), ' ', sample);
+ l_info("%-20s %*c%08x => %s", "", 1 + (indent * 2), ' ', data,
+ EVALNUM(sample, data));
+}
+
+static void verify_uint64(const char *label, unsigned int indent,
+ uint64_t sample, uint64_t data)
+{
+ l_info("%-20s =%*c%16llx", label, 1 + (indent * 2), ' ',
+ (long long unsigned int) sample);
+ l_info("%-20s %*c%16llx => %s", "", 1 + (indent * 2), ' ',
+ (long long unsigned int) data,
+ EVALNUM(sample, data));
+}
+
+static void show_str(const char *label, unsigned int indent,
+ const char *sample)
+{
+ char *printable = l_malloc(strlen(sample) + 1);
+ char *tmp = printable;
+
+ while (*sample) {
+ if (l_ascii_isprint(*sample))
+ *tmp++ = *sample++;
+ else {
+ *tmp++ = '?';
+ sample++;
+ }
+ }
+
+ *tmp = '\0';
+
+ l_info("%-20s =%*c%s", label, 1 + (indent * 2), ' ', printable);
+ l_free(printable);
+}
+
+static void show_data(const char *label, unsigned int indent,
+ const void *data, size_t size)
+{
+ char *str;
+
+ str = l_util_hexstring(data, size);
+ l_info("%-20s =%*c%s", label, 1 + (indent * 2), ' ', str);
+ l_free(str);
+}
+
+static void show_uint8(const char *label, unsigned int indent, uint8_t data)
+{
+ l_info("%-20s =%*c%2.2x", label, 1 + (indent * 2), ' ', data);
+}
+
+static void show_uint32(const char *label, unsigned int indent, uint32_t data)
+{
+ l_info("%-20s =%*c%8.8x", label, 1 + (indent * 2), ' ', data);
+}
+
+
+static void check_encrypt_segment(const struct mesh_crypto_test *keys,
+ uint16_t seg, uint16_t seg_max,
+ uint8_t *enc_msg, size_t len,
+ uint8_t *enc_key, uint8_t *priv_key,
+ uint8_t nid)
+{
+ uint8_t net_nonce[13];
+ uint8_t priv_rand[16];
+ uint8_t packet[29];
+ uint8_t packet_len;
+ uint64_t net_mic64;
+ uint32_t hdr, net_mic32;
+ size_t net_msg_len;
+ uint8_t key_aid = keys->key_aid | (keys->akf ? KEY_ID_AKF : 0x00);
+
+ if (keys->ctl) {
+ mesh_crypto_packet_build(keys->ctl, keys->net_ttl,
+ keys->net_seq[0],
+ keys->net_src, keys->net_dst,
+ keys->opcode,
+ keys->segmented, key_aid,
+ keys->szmic, keys->relay, keys->seqZero,
+ seg, seg_max,
+ enc_msg, len,
+ packet, &packet_len);
+ } else {
+ mesh_crypto_packet_build(keys->ctl, keys->net_ttl,
+ keys->net_seq[0],
+ keys->net_src, keys->net_dst,
+ keys->opcode,
+ keys->segmented, key_aid,
+ keys->szmic, keys->relay, keys->seqZero,
+ seg, seg_max,
+ enc_msg, len,
+ packet, &packet_len);
+ }
+
+ l_info(COLOR_YELLOW "Segment-%d" COLOR_OFF, seg);
+
+ hdr = l_get_be32(packet + 9);
+ verify_uint8("SEG", 9, keys->segmented << (SEG_HDR_SHIFT % 8),
+ packet[9] & (1 << (SEG_HDR_SHIFT % 8)));
+
+ if (keys->ctl) {
+ verify_uint8("Opcode", 9,
+ keys->opcode << (OPCODE_HDR_SHIFT % 8),
+ (packet[9] & OPCODE_MASK) <<
+ (OPCODE_HDR_SHIFT % 8));
+ } else {
+ verify_uint8("AKF", 9, keys->akf << (AKF_HDR_SHIFT % 8),
+ packet[9] & (1 << (AKF_HDR_SHIFT % 8)));
+ verify_uint8("AID", 9,
+ keys->key_aid << (KEY_HDR_SHIFT % 8),
+ (packet[9] & KEY_AID_MASK) <<
+ (KEY_HDR_SHIFT % 8));
+ }
+
+ verify_uint8("SZMIC", 10,
+ keys->szmic << (SZMIC_HDR_SHIFT % 8),
+ packet[10] & (1 << (SZMIC_HDR_SHIFT % 8)));
+
+ /* Awkward shift-by-two for correct display */
+ verify_uint16("SeqZero", 10,
+ (keys->seqZero & SEQ_ZERO_MASK) << 2,
+ ((hdr >> SEQ_ZERO_HDR_SHIFT) & SEQ_ZERO_MASK)
+ << 2);
+ verify_uint16("SegO", 11,
+ (seg & SEG_MASK) << SEGO_HDR_SHIFT,
+ hdr & (SEG_MASK << SEGO_HDR_SHIFT));
+ verify_uint8("SegN", 12,
+ (seg_max & SEG_MASK) << SEGN_HDR_SHIFT,
+ hdr & (SEG_MASK << SEGN_HDR_SHIFT));
+ show_data("Payload", 13, enc_msg, len);
+ len += 4;
+
+
+ mesh_crypto_network_nonce(keys->ctl, keys->net_ttl,
+ keys->net_seq[0], keys->net_src,
+ keys->iv_index, net_nonce);
+
+ verify_data("TransportData", 9, keys->trans_pkt[0],
+ packet + 9, len);
+
+ verify_uint16("DST", 7, keys->net_dst, l_get_be16(packet + 7));
+ net_msg_len = len + 2;
+ show_data("TransportPayload", 7, packet + 7, net_msg_len);
+
+ mesh_crypto_network_encrypt(keys->ctl,
+ keys->net_ttl, keys->net_seq[0],
+ keys->net_src,
+ keys->iv_index, enc_key,
+ packet + 7, len + 2, packet + 7,
+ keys->ctl ? (void *)&net_mic64 :
+ (void *)&net_mic32);
+
+ mesh_crypto_privacy_counter(keys->iv_index, packet + 7, priv_rand);
+
+ l_info("");
+ show_uint32("IVindex", 0, keys->iv_index);
+ verify_data("NetworkNonce", 0, keys->net_nonce[0], net_nonce, 13);
+ verify_data("PrivacyRandom", 0, keys->priv_rand[0], priv_rand, 16);
+
+ show_uint8("INI", 0, (keys->iv_index & 0x01) << 7);
+ verify_uint8("NID", 0, keys->net_nid, nid);
+ verify_uint8("CTL", 1, keys->ctl << 7, packet[1] & 0x80);
+ verify_uint8("TTL", 1, keys->net_ttl, packet[1] & 0x7f);
+ verify_uint24("SEQ", 2, keys->net_seq[0],
+ l_get_be32(packet + 1) & SEQ_MASK);
+ verify_uint16("SRC", 5, keys->net_src, l_get_be16(packet + 5));
+
+ verify_data("EncNetworkPayload", 7, keys->net_msg[0],
+ packet + 7, net_msg_len);
+ if (keys->ctl) {
+ verify_uint64("NetworkMIC", 7 + net_msg_len,
+ keys->net_mic64, net_mic64);
+ net_msg_len += 8;
+ } else {
+ verify_uint32("NetworkMIC", 7 + net_msg_len,
+ keys->net_mic32[0], net_mic32);
+ net_msg_len += 4;
+ }
+
+ show_data("PreObsPayload", 1, packet + 1, 6 + net_msg_len);
+ mesh_crypto_network_obfuscate(priv_key, priv_rand,
+ keys->ctl,
+ keys->net_ttl, keys->net_seq[0],
+ keys->net_src, packet + 1);
+ show_data("PostObsPayload", 1, packet + 1, 6 + net_msg_len);
+
+ packet[0] = (keys->iv_index & 0x01) << 7 | nid;
+ packet_len = 7 + net_msg_len;
+
+ verify_data("Packet", 0, keys->packet[0], packet, packet_len);
+ l_info("");
+
+}
+
+static void check_encrypt(const struct mesh_crypto_test *keys)
+{
+ uint8_t *dev_key;
+ uint8_t *app_key;
+ uint8_t *net_key;
+ uint8_t nid;
+ uint8_t enc_key[16];
+ uint8_t priv_key[16];
+ uint8_t net_nonce[13];
+ uint8_t app_nonce[13];
+ uint8_t priv_rand[16];
+ uint8_t p[9];
+ size_t p_len;
+ size_t aad_len = 0;
+ uint8_t *aad;
+ size_t app_msg_len;
+ uint8_t *app_msg = NULL;
+ uint8_t *enc_msg;
+ uint32_t app_mic32;
+ uint64_t app_mic64;
+ size_t net_msg_len;
+ uint32_t net_mic32;
+ uint64_t net_mic64;
+ uint8_t key_aid;
+ uint8_t packet[29];
+ uint8_t packet_len;
+ uint16_t i, seg_max, seg_len = 0;
+ uint32_t seqZero, hdr;
+
+ l_info(COLOR_BLUE "[Encrypt %s]" COLOR_OFF, keys->name);
+ verify_bool_not_both("CTL && Segmented", 0, keys->ctl, keys->segmented);
+
+ dev_key = l_util_from_hexstring(keys->dev_key, NULL);
+ app_key = l_util_from_hexstring(keys->app_key, NULL);
+ net_key = l_util_from_hexstring(keys->net_key, NULL);
+ aad = l_util_from_hexstring(keys->uuid, &aad_len);
+
+ show_data("NetworkKey", 0, net_key, 16);
+
+ if (keys->akf) {
+ mesh_crypto_k4(app_key, &key_aid);
+ key_aid |= KEY_ID_AKF;
+ } else {
+ key_aid = 0;
+ }
+
+ if (keys->frnd) {
+ uint8_t *lpn_addr, *fn_addr, *lpn_cntr, *fn_cntr;
+
+ lpn_addr = l_util_from_hexstring(keys->lpn_addr, NULL);
+ fn_addr = l_util_from_hexstring(keys->fn_addr, NULL);
+ lpn_cntr = l_util_from_hexstring(keys->lpn_cntr, NULL);
+ fn_cntr = l_util_from_hexstring(keys->fn_cntr, NULL);
+
+ show_data("LPN Address", 0, lpn_addr, 2);
+ show_data("Friend Address", 0, fn_addr, 2);
+ show_data("LPN Counter", 0, lpn_cntr, 2);
+ show_data("Friend Counter", 0, fn_cntr, 2);
+ l_info("");
+
+ p[0] = 1;
+ l_put_be16(l_get_be16(lpn_addr), p + 1);
+ l_put_be16(l_get_be16(fn_addr), p + 3);
+ l_put_be16(l_get_be16(lpn_cntr), p + 5);
+ l_put_be16(l_get_be16(fn_cntr), p + 7);
+ p_len = 9;
+
+ l_free(fn_cntr);
+ l_free(lpn_cntr);
+ l_free(fn_addr);
+ l_free(lpn_addr);
+ } else {
+ p[0] = 0;
+ p_len = 1;
+ }
+
+ if (p_len > 1) verify_data("P", 0, keys->p, p, p_len);
+
+ mesh_crypto_k2(net_key, p, p_len, &nid, enc_key, priv_key);
+
+ verify_data("EncryptionKey", 0, keys->enc_key, enc_key,
+ sizeof(enc_key));
+ verify_data("PrivacyKey", 0, keys->priv_key, priv_key,
+ sizeof(priv_key));
+ verify_uint8("NID", 0, keys->net_nid, nid);
+
+ if (keys->network_only) {
+ enc_msg = l_util_from_hexstring(keys->trans_pkt[0],
+ &app_msg_len);
+ check_encrypt_segment(keys, keys->seg_num, keys->seg_max,
+ enc_msg + 4, app_msg_len - 4,
+ enc_key, priv_key, nid);
+ goto done;
+ }
+
+ if (keys->akf)
+ mesh_crypto_application_nonce(keys->app_seq, keys->net_src,
+ keys->net_dst, keys->iv_index,
+ keys->szmic, app_nonce);
+ else
+ mesh_crypto_device_nonce(keys->app_seq, keys->net_src,
+ keys->net_dst, keys->iv_index,
+ keys->szmic, app_nonce);
+
+ seqZero = keys->app_seq;
+
+ if (!keys->ctl) {
+ app_msg = l_util_from_hexstring(keys->app_msg, &app_msg_len);
+
+ if (keys->szmic) {
+ seg_max = SEG_MAX(app_msg_len + 8);
+ enc_msg = l_malloc(app_msg_len + 8);
+ mesh_crypto_application_encrypt(key_aid, keys->app_seq,
+ keys->net_src, keys->net_dst,
+ keys->iv_index,
+ keys->akf ? app_key : dev_key,
+ aad, aad_len,
+ app_msg, app_msg_len,
+ enc_msg, &app_mic64, sizeof(app_mic64));
+ l_put_be64(app_mic64, enc_msg + app_msg_len);
+ } else {
+ seg_max = SEG_MAX(app_msg_len + 4);
+ enc_msg = l_malloc(app_msg_len + 4);
+ mesh_crypto_application_encrypt(key_aid, keys->app_seq,
+ keys->net_src, keys->net_dst,
+ keys->iv_index,
+ keys->akf ? app_key : dev_key,
+ aad, aad_len,
+ app_msg, app_msg_len,
+ enc_msg, &app_mic32, sizeof(app_mic32));
+ l_put_be32(app_mic32, enc_msg + app_msg_len);
+ }
+
+ if (keys->dev_key && !keys->akf)
+ show_data("DeviceKey", 0, dev_key, 16);
+
+ if (keys->app_key && keys->akf)
+ show_data("ApplicationKey", 0, app_key, 16);
+
+ if (aad) show_data("UUID", 0, aad, 16);
+
+ verify_data("EncryptionKey", 0, keys->enc_key, enc_key, 16);
+ verify_data("ApplicationNonce", 0, keys->app_nonce,
+ app_nonce, 13);
+ verify_data("PrivacyKey", 0, keys->priv_key, priv_key, 16);
+
+ show_data("AppPayload", 0, app_msg, app_msg_len);
+ verify_data("EncryptedAppPayload", 0, keys->enc_msg, enc_msg,
+ app_msg_len);
+ if (keys->szmic) {
+ verify_uint64("ApplicationMIC", app_msg_len,
+ keys->app_mic64, app_mic64);
+ app_msg_len += 8;
+ } else {
+ verify_uint32("ApplicationMIC", app_msg_len,
+ keys->app_mic32, app_mic32);
+ app_msg_len += 4;
+ }
+ } else {
+ enc_msg = l_util_from_hexstring(keys->trans_pkt[0],
+ &app_msg_len);
+ seg_max = 0;
+ app_msg_len--;
+ }
+
+ for (i = 0; i <= seg_max; i++) {
+ if (seg_max) {
+ if (i < seg_max || !(app_msg_len % 12))
+ seg_len = 12;
+ else
+ seg_len = app_msg_len % 12;
+ } else {
+ seg_len = app_msg_len;
+ }
+
+ if (keys->ctl) {
+ mesh_crypto_packet_build(keys->ctl, keys->net_ttl,
+ keys->net_seq[i],
+ keys->net_src, keys->net_dst,
+ keys->opcode,
+ keys->segmented, key_aid,
+ keys->szmic, keys->relay, keys->seqZero,
+ i, seg_max,
+ enc_msg + 1, seg_len,
+ packet, &packet_len);
+ } else {
+ mesh_crypto_packet_build(keys->ctl, keys->net_ttl,
+ keys->net_seq[i],
+ keys->net_src, keys->net_dst,
+ keys->opcode,
+ keys->segmented, key_aid,
+ keys->szmic, keys->relay, seqZero,
+ i, seg_max,
+ enc_msg + (i * 12), seg_len,
+ packet, &packet_len);
+ }
+
+ if (seg_max) l_info(COLOR_YELLOW "Segment-%d" COLOR_OFF, i);
+
+ hdr = l_get_be32(packet + 9);
+ verify_uint8("SEG", 9, keys->segmented << (SEG_HDR_SHIFT % 8),
+ packet[9] & (1 << (SEG_HDR_SHIFT % 8)));
+
+ if (keys->ctl) {
+ verify_uint8("Opcode", 9,
+ keys->opcode << (OPCODE_HDR_SHIFT % 8),
+ (packet[9] & OPCODE_MASK) <<
+ (OPCODE_HDR_SHIFT % 8));
+ } else {
+ verify_uint8("AKF", 9, keys->akf << (AKF_HDR_SHIFT % 8),
+ packet[9] & (1 << (AKF_HDR_SHIFT % 8)));
+ verify_uint8("AID", 9,
+ keys->key_aid << (KEY_HDR_SHIFT % 8),
+ (packet[9] & KEY_AID_MASK) <<
+ (KEY_HDR_SHIFT % 8));
+ }
+
+ if (seg_max == 0) {
+ if (!keys->ctl) {
+ show_data("Payload", 10, app_msg, seg_len - 4);
+ show_data("EncryptedPayload", 10, packet + 10,
+ seg_len);
+ } else if (keys->opcode == NET_OP_SEG_ACKNOWLEDGE) {
+ verify_uint8("Relay", 10,
+ keys->relay << (RELAY_HDR_SHIFT % 8),
+ packet[10] &
+ (1 << (RELAY_HDR_SHIFT % 8)));
+
+ /* Awkward shift-by-two for correct display */
+ verify_uint16("SeqZero", 10,
+ (keys->seqZero & SEQ_ZERO_MASK) << 2,
+ ((hdr >> SEQ_ZERO_HDR_SHIFT) &
+ SEQ_ZERO_MASK) << 2);
+
+ show_data("Payload", 12, packet + 12, seg_len);
+ } else {
+ show_data("Payload", 10, packet + 10, seg_len);
+ }
+ seg_len += 1;
+ } else {
+
+ verify_uint8("SZMIC", 10,
+ keys->szmic << (SZMIC_HDR_SHIFT % 8),
+ packet[10] & (1 << (SZMIC_HDR_SHIFT % 8)));
+
+ /* Awkward shift-by-two for correct display */
+ verify_uint16("SeqZero", 10,
+ (keys->app_seq & SEQ_ZERO_MASK) << 2,
+ ((hdr >> SEQ_ZERO_HDR_SHIFT) & SEQ_ZERO_MASK)
+ << 2);
+ verify_uint16("SegO", 11,
+ (i & SEG_MASK) << SEGO_HDR_SHIFT,
+ hdr & (SEG_MASK << SEGO_HDR_SHIFT));
+ verify_uint8("SegN", 12,
+ (seg_max & SEG_MASK) << SEGN_HDR_SHIFT,
+ hdr & (SEG_MASK << SEGN_HDR_SHIFT));
+ show_data("Payload", 13, enc_msg + (i * 12), seg_len);
+ seg_len += 4;
+ }
+
+
+ mesh_crypto_network_nonce(keys->ctl, keys->net_ttl,
+ keys->net_seq[i], keys->net_src,
+ keys->iv_index, net_nonce);
+
+ verify_data("TransportData", 9, keys->trans_pkt[i],
+ packet + 9, seg_len);
+
+ verify_uint16("DST", 7, keys->net_dst, l_get_be16(packet + 7));
+ net_msg_len = seg_len + 2;
+ show_data("TransportPayload", 7, packet + 7, net_msg_len);
+
+ mesh_crypto_network_encrypt(keys->ctl,
+ keys->net_ttl, keys->net_seq[i],
+ keys->net_src,
+ keys->iv_index, enc_key,
+ packet + 7, seg_len + 2, packet + 7,
+ keys->ctl ? (void *)&net_mic64 :
+ (void *)&net_mic32);
+
+ mesh_crypto_privacy_counter(keys->iv_index, packet + 7,
+ priv_rand);
+
+ l_info("");
+ show_uint32("IVindex", 0, keys->iv_index);
+ verify_data("NetworkNonce", 0, keys->net_nonce[i],
+ net_nonce, 13);
+ verify_data("PrivacyRandom", 0, keys->priv_rand[i],
+ priv_rand, 16);
+
+ show_uint8("INI", 0, (keys->iv_index & 0x01) << 7);
+ verify_uint8("NID", 0, keys->net_nid, nid);
+ verify_uint8("CTL", 1, keys->ctl << 7, packet[1] & 0x80);
+ verify_uint8("TTL", 1, keys->net_ttl, packet[1] & 0x7f);
+ verify_uint24("SEQ", 2, keys->net_seq[i],
+ l_get_be32(packet + 1) & SEQ_MASK);
+ verify_uint16("SRC", 5, keys->net_src, l_get_be16(packet + 5));
+
+ verify_data("EncNetworkPayload", 7, keys->net_msg[i],
+ packet + 7, net_msg_len);
+ if (keys->ctl) {
+ verify_uint64("NetworkMIC", 7 + net_msg_len,
+ keys->net_mic64, net_mic64);
+ net_msg_len += 8;
+ } else {
+ verify_uint32("NetworkMIC", 7 + net_msg_len,
+ keys->net_mic32[i], net_mic32);
+ net_msg_len += 4;
+ }
+
+ show_data("PreObsPayload", 1, packet + 1, 6 + net_msg_len);
+ mesh_crypto_network_obfuscate(priv_key, priv_rand,
+ keys->ctl,
+ keys->net_ttl, keys->net_seq[i],
+ keys->net_src, packet + 1);
+ show_data("PostObsPayload", 1, packet + 1, 6 + net_msg_len);
+
+ packet[0] = (keys->iv_index & 0x01) << 7 | nid;
+ packet_len = 7 + net_msg_len;
+
+ verify_data("Packet", 0, keys->packet[i], packet, packet_len);
+ l_info("");
+ }
+
+done:
+ l_free(dev_key);
+ l_free(app_key);
+ l_free(aad);
+ l_free(net_key);
+ l_free(app_msg);
+ l_free(enc_msg);
+}
+
+static void check_decrypt_segment(const struct mesh_crypto_test *keys,
+ uint16_t seg, uint16_t seg_max,
+ const uint8_t *pkt, uint8_t pkt_len,
+ const uint8_t *msg, uint8_t msg_len,
+ uint8_t *enc_key, uint8_t *priv_key,
+ uint8_t nid)
+{
+ uint8_t net_clr[29];
+ uint64_t net_mic64, calc_net_mic64;
+ uint32_t hdr, net_mic32, calc_net_mic32;
+ bool ctl, segmented, relay, szmic, key_akf;
+ uint8_t ttl, opcode, key_aid, segO, segN;
+ uint32_t seq;
+ uint16_t src, dst, seqZero;
+
+ memcpy(net_clr, pkt, pkt_len);
+ show_data("NetworkMessage", 0, pkt, pkt_len);
+ mesh_crypto_packet_decode(pkt, pkt_len,
+ false, net_clr, keys->iv_index,
+ enc_key, priv_key);
+ show_data("Decoded", 0, net_clr, pkt_len);
+
+ mesh_crypto_packet_parse(net_clr, pkt_len,
+ &ctl, &ttl, &seq,
+ &src, &dst,
+ NULL, &opcode,
+ &segmented, &key_aid,
+ &szmic, &relay, &seqZero,
+ &segO, &segN,
+ &msg, &msg_len);
+
+ if (ctl) {
+ net_mic64 = l_get_be64(pkt + pkt_len - 8);
+ show_data("EncryptedPayload", 7, pkt + 7, pkt_len - 7 - 8);
+ mesh_crypto_network_decrypt(ctl, ttl, seq,
+ src, keys->iv_index, enc_key,
+ pkt + 7, pkt_len - 7, net_clr + 7,
+ &calc_net_mic64,
+ sizeof(calc_net_mic64));
+ verify_uint64("NetworkMIC", pkt_len - 8, net_mic64,
+ calc_net_mic64);
+ show_data("DecryptedPayload", 7, net_clr + 7, pkt_len - 7 - 8);
+ } else {
+ net_mic32 = l_get_be32(pkt + pkt_len - 4);
+ show_data("EncryptedPayload", 7, pkt + 7, pkt_len - 7 - 4);
+
+ mesh_crypto_network_decrypt(ctl, ttl, seq,
+ src, keys->iv_index, enc_key,
+ pkt + 7, pkt_len - 7, net_clr + 7,
+ &calc_net_mic32,
+ sizeof(calc_net_mic32));
+
+ verify_uint32("NetworkMIC", pkt_len - 4, net_mic32,
+ calc_net_mic32);
+ show_data("DecryptedPayload", 7, net_clr + 7, pkt_len - 7 - 4);
+ }
+
+ hdr = l_get_be32(net_clr + 9);
+
+ segmented = !!((hdr >> SEG_HDR_SHIFT) & 1);
+ if (ctl) {
+ opcode = (hdr >> OPCODE_HDR_SHIFT) & OPCODE_MASK;
+ if (opcode == NET_OP_SEG_ACKNOWLEDGE) {
+ relay = !!((hdr >> RELAY_HDR_SHIFT) & 1);
+ seqZero = (hdr >> SEQ_ZERO_HDR_SHIFT) & SEQ_ZERO_MASK;
+ verify_uint24("SeqZero", 9,
+ ((keys->seqZero) & SEQ_ZERO_MASK)
+ << (SEQ_ZERO_HDR_SHIFT - 8),
+ seqZero << (SEQ_ZERO_HDR_SHIFT - 8));
+ verify_uint24("Relay", 9,
+ keys->relay << (RELAY_HDR_SHIFT - 8),
+ relay << (RELAY_HDR_SHIFT - 8));
+ verify_uint24("Opcode", 9,
+ keys->opcode << (OPCODE_HDR_SHIFT - 8),
+ opcode << (OPCODE_HDR_SHIFT - 8));
+ verify_uint24("SEGMENTED", 9,
+ keys->segmented << (SEG_HDR_SHIFT - 8),
+ segmented << (SEG_HDR_SHIFT - 8));
+ } else {
+ verify_uint8("Opcode", 9,
+ keys->opcode << (OPCODE_HDR_SHIFT % 8),
+ opcode << (OPCODE_HDR_SHIFT % 8));
+ verify_uint8("SEGMENTED", 9,
+ keys->segmented << (SEG_HDR_SHIFT % 8),
+ segmented << (SEG_HDR_SHIFT % 8));
+ }
+ } else {
+ key_akf = !!((hdr >> AKF_HDR_SHIFT) & 1);
+ key_aid = (hdr >> KEY_HDR_SHIFT) & KEY_AID_MASK;
+ if (segmented) {
+ show_data("EncryptedApp", 13, net_clr + 13,
+ pkt_len - 13 - 4);
+ segN = (hdr >> SEGN_HDR_SHIFT) & SEG_MASK;
+ segO = (hdr >> SEGO_HDR_SHIFT) & SEG_MASK;
+ seqZero = ((hdr >> SEQ_ZERO_HDR_SHIFT) &
+ SEQ_ZERO_MASK);
+
+ verify_uint32("SegN", 9,
+ seg_max << SEGN_HDR_SHIFT,
+ segN << SEGN_HDR_SHIFT);
+ verify_uint32("SegO", 9, seg << SEGO_HDR_SHIFT,
+ segO << SEGO_HDR_SHIFT);
+ verify_uint32("SeqZero", 9,
+ (keys->seqZero & SEQ_ZERO_MASK)
+ << SEQ_ZERO_HDR_SHIFT,
+ (seqZero & SEQ_ZERO_MASK)
+ << SEQ_ZERO_HDR_SHIFT);
+ verify_uint32("AID", 9,
+ keys->key_aid << KEY_HDR_SHIFT,
+ key_aid << KEY_HDR_SHIFT);
+ verify_uint32("AKF", 9,
+ keys->akf << AKF_HDR_SHIFT,
+ key_akf << AKF_HDR_SHIFT);
+ verify_uint32("SEGMENTED", 9,
+ keys->segmented << SEG_HDR_SHIFT,
+ segmented << SEG_HDR_SHIFT);
+ } else {
+ show_data("EncryptedApp", 10, msg + 3, pkt_len - 3);
+ verify_uint8("AID", 9,
+ keys->key_aid << (KEY_HDR_SHIFT % 8),
+ key_aid << (KEY_HDR_SHIFT % 8));
+ verify_uint8("AKF", 9,
+ keys->akf << (AKF_HDR_SHIFT % 8),
+ key_aid << (AKF_HDR_SHIFT % 8));
+ verify_uint8("SEGMENTED", 9,
+ keys->segmented << (SEG_HDR_SHIFT % 8),
+ segmented << (SEG_HDR_SHIFT % 8));
+ }
+ }
+
+ dst = l_get_be16(net_clr + 7);
+
+ verify_uint16("DST", 7, keys->net_dst, dst);
+ verify_uint16("SRC", 5, keys->net_src, src);
+ verify_uint24("SEQ", 2, keys->net_seq[0], seq);
+ verify_uint8("TTL", 1, keys->net_ttl, ttl);
+ verify_uint8("CTL", 1, keys->ctl << 7, ctl << 7);
+ verify_uint8("NID", 0, keys->net_nid, net_clr[0] & 0x7f);
+ verify_uint8("INI", 0, (keys->iv_index & 0x01) << 7, net_clr[0] & 0x80);
+}
+
+static void check_decrypt(const struct mesh_crypto_test *keys)
+{
+ uint8_t *dev_key;
+ uint8_t *app_key;
+ uint8_t *net_key;
+ uint8_t enc_key[16];
+ uint8_t net_nonce[13];
+ uint8_t app_nonce[13];
+ uint8_t priv_key[16];
+ uint8_t priv_rand[16];
+ uint8_t p[9];
+ size_t p_len;
+ uint8_t *packet;
+ size_t packet_len;
+ const uint8_t *net_hdr;
+ uint8_t *net_msg;
+ uint8_t net_msg_len;
+ uint16_t app_msg_len = 0;
+ uint32_t calc_net_mic32, net_mic32 = 0;
+ uint64_t calc_net_mic64, net_mic64 = 0;
+ bool net_ctl, net_segmented, net_rly, net_akf;
+ uint8_t net_aid, net_ttl, nid, net_segO, net_segN = 0;
+ uint32_t net_seq, hdr, seqZero = 0;
+ uint16_t net_src, net_dst;
+ uint32_t calc_app_mic32;
+ uint64_t calc_app_mic64;
+ uint32_t app_mic32;
+ uint64_t app_mic64;
+ uint8_t *app_msg;
+ uint8_t *aad;
+ uint8_t *payload;
+ size_t trans_msg_len, payload_len, aad_len = 0;
+ uint8_t pkt_len, hdr_len, net_op = 0;
+ uint16_t i, seg_max;
+ uint8_t keys_aid = 0;
+
+ l_info(COLOR_BLUE "[Decrypt %s]" COLOR_OFF, keys->name);
+ verify_bool_not_both("CTL && Segmented", 0, keys->ctl, keys->segmented);
+ dev_key = l_util_from_hexstring(keys->dev_key, NULL);
+ app_key = l_util_from_hexstring(keys->app_key, NULL);
+ net_key = l_util_from_hexstring(keys->net_key, NULL);
+ aad = l_util_from_hexstring(keys->uuid, &aad_len);
+
+ if (keys->frnd) {
+ uint8_t *lpn_addr, *fn_addr, *lpn_cntr, *fn_cntr;
+
+ lpn_addr = l_util_from_hexstring(keys->lpn_addr, NULL);
+ fn_addr = l_util_from_hexstring(keys->fn_addr, NULL);
+ lpn_cntr = l_util_from_hexstring(keys->lpn_cntr, NULL);
+ fn_cntr = l_util_from_hexstring(keys->fn_cntr, NULL);
+
+ show_data("LPN Address", 0, lpn_addr, 2);
+ show_data("Friend Address", 0, fn_addr, 2);
+ show_data("LPN Counter", 0, lpn_cntr, 2);
+ show_data("Friend Counter", 0, fn_cntr, 2);
+ l_info("");
+
+ p[0] = 1;
+ l_put_be16(l_get_be16(lpn_addr), p + 1);
+ l_put_be16(l_get_be16(fn_addr), p + 3);
+ l_put_be16(l_get_be16(lpn_cntr), p + 5);
+ l_put_be16(l_get_be16(fn_cntr), p + 7);
+ p_len = 9;
+
+ l_free(fn_cntr);
+ l_free(lpn_cntr);
+ l_free(fn_addr);
+ l_free(lpn_addr);
+ } else {
+ p[0] = 0;
+ p_len = 1;
+ }
+
+ if (p_len > 1) verify_data("P", 0, keys->p, p, p_len);
+ mesh_crypto_k2(net_key, p, p_len, &nid, enc_key, priv_key);
+
+
+ if (keys->network_only) {
+ app_msg = l_util_from_hexstring(keys->trans_pkt[0],
+ &trans_msg_len);
+ packet = l_util_from_hexstring(keys->packet[0], &packet_len);
+ check_decrypt_segment(keys, keys->seg_num, keys->seg_max,
+ packet, packet_len,
+ app_msg + 4, trans_msg_len - 4,
+ enc_key, priv_key, nid);
+ goto done;
+ }
+
+ mesh_crypto_application_nonce(keys->app_seq, keys->net_src,
+ keys->net_dst, keys->iv_index,
+ keys->szmic, app_nonce);
+ app_msg = l_malloc(384);
+
+ seg_max = (sizeof(keys->packet) / sizeof(keys->packet[0])) - 1;
+
+ /* Calculate number of segments in sample data */
+ while (keys->packet[seg_max] == NULL && seg_max) seg_max--;
+
+ for (i = 0; i <= seg_max; i++) {
+ if (keys->segmented)
+ l_info(COLOR_YELLOW "Segment-%d" COLOR_OFF, i);
+
+ mesh_crypto_network_nonce(keys->frnd, keys->net_ttl,
+ keys->net_seq[i], keys->net_src, keys->iv_index,
+ net_nonce);
+ packet = l_util_from_hexstring(keys->packet[i], &packet_len);
+
+ net_hdr = packet + 1;
+ net_msg = packet + 7;
+ net_msg_len = packet_len - 7;
+
+ mesh_crypto_privacy_counter(keys->iv_index, net_msg, priv_rand);
+
+ mesh_crypto_network_clarify(priv_key, priv_rand, net_hdr,
+ &net_ctl, &net_ttl, &net_seq, &net_src);
+
+ show_str("Packet", 0, keys->packet[i]);
+
+ if (net_ctl) {
+ net_mic64 = l_get_be64(packet + packet_len - 8);
+ show_data("NetworkMessage", 7, net_msg,
+ net_msg_len - 8);
+ mesh_crypto_network_decrypt(net_ctl, net_ttl, net_seq,
+ net_src, keys->iv_index, enc_key,
+ net_msg, net_msg_len, net_msg,
+ &calc_net_mic64,
+ sizeof(calc_net_mic64));
+ net_msg_len -= 8;
+ verify_uint64("NetworkMIC", 7 + net_msg_len, net_mic64,
+ calc_net_mic64);
+ show_data("DecryptedNetwork", 7, net_msg, net_msg_len);
+ } else {
+ net_mic32 = l_get_be32(packet + packet_len - 4);
+ show_data("NetworkMessage", 7, net_msg,
+ net_msg_len - 4);
+
+ mesh_crypto_network_decrypt(net_ctl, net_ttl, net_seq,
+ net_src, keys->iv_index, enc_key,
+ net_msg, net_msg_len, net_msg,
+ &calc_net_mic32,
+ sizeof(calc_net_mic32));
+
+ net_msg_len -= 4;
+ verify_uint32("NetworkMIC", 7 + net_msg_len, net_mic32,
+ calc_net_mic32);
+ show_data("DecryptedNetwork", 7, net_msg, net_msg_len);
+ }
+
+
+ hdr = l_get_be32(packet + 9);
+
+ net_segmented = !!((hdr >> SEG_HDR_SHIFT) & 1);
+ if (net_ctl) {
+ net_op = (hdr >> OPCODE_HDR_SHIFT) & OPCODE_MASK;
+ hdr_len = 1;
+ if (net_op == NET_OP_SEG_ACKNOWLEDGE) {
+ net_rly = !!((hdr >> RELAY_HDR_SHIFT) & 1);
+ seqZero = (hdr >> SEQ_ZERO_HDR_SHIFT) &
+ SEQ_ZERO_MASK;
+ verify_uint24("SeqZero", 9,
+ ((keys->seqZero) & SEQ_ZERO_MASK)
+ << (SEQ_ZERO_HDR_SHIFT - 8),
+ seqZero << (SEQ_ZERO_HDR_SHIFT - 8));
+ verify_uint24("Relay", 9,
+ keys->relay << (RELAY_HDR_SHIFT - 8),
+ net_rly << (RELAY_HDR_SHIFT - 8));
+ verify_uint24("Opcode", 9,
+ keys->opcode << (OPCODE_HDR_SHIFT - 8),
+ net_op << (OPCODE_HDR_SHIFT - 8));
+ verify_uint24("SEGMENTED", 9,
+ keys->segmented << (SEG_HDR_SHIFT - 8),
+ net_segmented << (SEG_HDR_SHIFT - 8));
+ } else {
+ verify_uint8("Opcode", 9,
+ keys->opcode << (OPCODE_HDR_SHIFT % 8),
+ net_op << (OPCODE_HDR_SHIFT % 8));
+ verify_uint8("SEGMENTED", 9,
+ keys->segmented << (SEG_HDR_SHIFT % 8),
+ net_segmented << (SEG_HDR_SHIFT % 8));
+ }
+ } else {
+ net_akf = !!((hdr >> AKF_HDR_SHIFT) & 1);
+ net_aid = (hdr >> KEY_HDR_SHIFT) & KEY_AID_MASK;
+ if (net_segmented) {
+ hdr_len = 4;
+ show_data("EncryptedApp", 13, net_msg + 6,
+ net_msg_len - 6);
+ memcpy(app_msg + (12 * i), net_msg + 6,
+ net_msg_len - 6);
+ app_msg_len += net_msg_len - 6;
+ net_segN = (hdr >> SEGN_HDR_SHIFT) & SEG_MASK;
+ net_segO = (hdr >> SEGO_HDR_SHIFT) & SEG_MASK;
+ seqZero = ((hdr >> SEQ_ZERO_HDR_SHIFT)
+ & SEQ_ZERO_MASK) |
+ (net_seq & ~SEQ_ZERO_MASK);
+
+ if (seqZero > net_seq) seqZero -=
+ (SEQ_ZERO_MASK + 1);
+ verify_uint32("SegN", 9,
+ seg_max << SEGN_HDR_SHIFT,
+ net_segN << SEGN_HDR_SHIFT);
+ verify_uint32("SegO", 9, i << SEGO_HDR_SHIFT,
+ net_segO << SEGO_HDR_SHIFT);
+ verify_uint32("SeqZero", 9,
+ (keys->app_seq & SEQ_ZERO_MASK)
+ << SEQ_ZERO_HDR_SHIFT,
+ (seqZero & SEQ_ZERO_MASK)
+ << SEQ_ZERO_HDR_SHIFT);
+ verify_uint32("AID", 9,
+ keys->key_aid << KEY_HDR_SHIFT,
+ net_aid << KEY_HDR_SHIFT);
+ verify_uint32("AKF", 9,
+ keys->akf << AKF_HDR_SHIFT,
+ net_akf << AKF_HDR_SHIFT);
+ verify_uint32("SEGMENTED", 9,
+ keys->segmented << SEG_HDR_SHIFT,
+ net_segmented << SEG_HDR_SHIFT);
+ } else {
+ hdr_len = 1;
+ show_data("EncryptedApp", 10, net_msg + 3,
+ net_msg_len - 3);
+ memcpy(app_msg + (12 * i), net_msg + 3,
+ net_msg_len - 3);
+ app_msg_len += net_msg_len - 3;
+ seqZero = net_seq;
+ verify_uint8("AID", 9,
+ keys->key_aid << (KEY_HDR_SHIFT % 8),
+ net_aid << (KEY_HDR_SHIFT % 8));
+ verify_uint8("AKF", 9,
+ keys->akf << (AKF_HDR_SHIFT % 8),
+ net_akf << (AKF_HDR_SHIFT % 8));
+ verify_uint8("SEGMENTED", 9,
+ keys->segmented << (SEG_HDR_SHIFT % 8),
+ net_segmented << (SEG_HDR_SHIFT % 8));
+ }
+ }
+
+ net_dst = l_get_be16(net_msg);
+
+ verify_uint16("DST", 7, keys->net_dst, net_dst);
+ verify_uint16("SRC", 5, keys->net_src, net_src);
+ verify_uint24("SEQ", 2, keys->net_seq[i], net_seq);
+ verify_uint8("TTL", 1, keys->net_ttl, net_ttl);
+ verify_uint8("CTL", 1, keys->ctl << 7, net_ctl << 7);
+ verify_uint8("NID", 0, keys->net_nid, nid);
+ verify_uint8("INI", 0, (keys->iv_index & 0x01) << 7,
+ packet[0] & 0x80);
+
+ payload = l_util_from_hexstring(keys->trans_pkt[i],
+ &payload_len);
+ memset(packet, 0, packet_len);
+
+ mesh_crypto_packet_build(keys->ctl, keys->net_ttl,
+ keys->net_seq[i], keys->net_src,
+ keys->net_dst, net_op,
+ keys->segmented,
+ keys->key_aid | (keys->akf ? KEY_ID_AKF : 0),
+ keys->szmic, keys->relay, seqZero,
+ i, seg_max,
+ payload + hdr_len, payload_len - hdr_len,
+ packet, &pkt_len);
+ verify_data("TransportData", 9, keys->trans_pkt[i], packet + 9,
+ payload_len);
+ mesh_crypto_packet_encode(packet, pkt_len, enc_key,
+ keys->iv_index, priv_key);
+ mesh_crypto_packet_label(packet, pkt_len, keys->iv_index, nid);
+
+ verify_data("Encoded-Packet", 0, keys->packet[i], packet,
+ pkt_len);
+
+ l_free(payload);
+
+ l_info("");
+ mesh_crypto_packet_decode(packet, pkt_len, false, packet,
+ keys->iv_index, enc_key, priv_key);
+ show_data("Decoded-Packet", 0, packet, pkt_len);
+ l_info("");
+ }
+
+ if (keys->segmented && keys->szmic) {
+ verify_data("EncryptedPayload", 0, keys->enc_msg, app_msg,
+ app_msg_len - 8);
+ app_mic64 = l_get_be64(app_msg + app_msg_len - 8);
+
+ mesh_crypto_application_decrypt(
+ keys_aid | (keys->akf ? KEY_ID_AKF : 0),
+ seqZero, net_src,
+ net_dst, keys->iv_index,
+ keys->akf ? app_key : dev_key,
+ aad, aad_len,
+ app_msg, app_msg_len,
+ app_msg, &calc_app_mic64,
+ sizeof(calc_app_mic64));
+
+ verify_data("Payload", 0, keys->app_msg, app_msg,
+ app_msg_len - 8);
+ verify_uint64("ApplicationMIC", app_msg_len - 8, app_mic64,
+ calc_app_mic64);
+ } else if (!keys->ctl) {
+ verify_data("EncryptedPayload", 0, keys->enc_msg, app_msg,
+ app_msg_len - 4);
+ app_mic32 = l_get_be32(app_msg + app_msg_len - 4);
+
+ mesh_crypto_application_decrypt(
+ keys_aid | (keys->akf ? KEY_ID_AKF : 0),
+ seqZero, net_src,
+ net_dst, keys->iv_index,
+ keys->akf ? app_key : dev_key,
+ aad, aad_len,
+ app_msg, app_msg_len,
+ app_msg, &calc_app_mic32,
+ sizeof(calc_app_mic32));
+
+ verify_data("Payload", 0, keys->app_msg, app_msg,
+ app_msg_len - 4);
+ verify_uint32("ApplicationMIC", app_msg_len - 4, app_mic32,
+ calc_app_mic32);
+ }
+
+done:
+
+ l_info("");
+
+ l_free(dev_key);
+ l_free(aad);
+ l_free(app_key);
+ l_free(net_key);
+ l_free(app_msg);
+ l_free(packet);
+}
+
+static void check_beacon(const struct mesh_crypto_test *keys)
+{
+ uint8_t *net_key;
+ uint8_t *beacon_cmac;
+ uint8_t beacon[22];
+ uint8_t enc_key[16];
+ uint8_t net_id[8];
+ uint8_t cmac[8];
+ uint64_t cmac_tmp;
+
+ net_key = l_util_from_hexstring(keys->net_key, NULL);
+ beacon_cmac = l_util_from_hexstring(keys->beacon_cmac, NULL);
+
+ mesh_crypto_nkbk(net_key, enc_key);
+ mesh_crypto_k3(net_key, net_id);
+
+ l_info(COLOR_BLUE "[%s]" COLOR_OFF, keys->name);
+
+ verify_data("NetworkKey", 0, keys->net_key, net_key, 16);
+ show_uint32("IVindex", 0, keys->iv_index);
+
+ verify_data("BeaconKey", 0, keys->enc_key, enc_key, 16);
+ verify_data("NetworkID", 0, keys->net_id, net_id, 8);
+
+ beacon[0] = keys->beacon_type;
+ beacon[1] = keys->beacon_flags;
+ memcpy(beacon + 2, net_id, 8);
+ l_put_be32(keys->iv_index, beacon + 10);
+ mesh_crypto_beacon_cmac(enc_key, net_id, keys->iv_index,
+ !!(keys->beacon_flags & 0x01),
+ !!(keys->beacon_flags & 0x02),
+ &cmac_tmp);
+
+ l_put_be64(cmac_tmp, cmac);
+ l_put_be64(cmac_tmp, beacon + 14);
+ verify_data("BeaconCMAC", 0, keys->beacon_cmac, cmac, 8);
+ verify_data("Beacon", 0, keys->beacon, beacon, sizeof(beacon));
+
+ l_info("");
+
+ l_free(beacon_cmac);
+ l_free(net_key);
+}
+
+static void check_id_beacon(const struct mesh_crypto_test *keys)
+{
+ uint8_t *net_key;
+ uint8_t *rand;
+ uint8_t identity_key[16];
+ uint8_t hash_input[16];
+ uint8_t hash[16];
+ uint8_t beacon[17];
+
+ net_key = l_util_from_hexstring(keys->net_key, NULL);
+ rand = l_util_from_hexstring(keys->rand, NULL);
+
+ mesh_crypto_nkik(net_key, identity_key);
+
+ l_info(COLOR_BLUE "[%s]" COLOR_OFF, keys->name);
+
+ verify_data("ID Resolving Key", 0, keys->ident_res_key,
+ identity_key, 16);
+ memset(hash_input, 0, 6);
+ memcpy(hash_input + 6, rand, 8);
+ l_put_be16(keys->net_src, hash_input + 6 + 8);
+
+ verify_data("Hash Input", 0, keys->hash_input, hash_input, 16);
+ aes_ecb_one(identity_key, hash_input, hash);
+
+ verify_data("Hash", 0, keys->identity_hash, hash + 8, 8);
+
+ beacon[0] = 0x01;
+ memcpy(beacon + 1, hash + 8, 8);
+ memcpy(beacon + 9, rand, 8);
+
+ verify_data("Mesh ID Beacon", 0, keys->beacon, beacon, 17);
+
+ l_info("");
+
+ l_free(net_key);
+}
+
+static void check_s1(const struct mesh_crypto_test *keys)
+{
+ uint8_t salt_out[16];
+
+ l_info(COLOR_BLUE "[%s]" COLOR_OFF, keys->name);
+
+ show_str("Salt Input", 0, keys->salt);
+ show_data("Salt Input", 0, keys->salt, strlen(keys->salt));
+ mesh_crypto_s1(keys->salt, strlen(keys->salt), salt_out);
+
+ verify_data("s1(Salt)", 0, keys->salt_out, salt_out, 16);
+ l_info("");
+}
+
+static void check_k128(const struct mesh_crypto_test *keys)
+{
+ uint8_t salt[16];
+ uint8_t t[16];
+ uint8_t enc_key[16];
+ uint8_t *net_key;
+
+ l_info(COLOR_BLUE "[%s]" COLOR_OFF, keys->name);
+
+ net_key = l_util_from_hexstring(keys->net_key, NULL);
+ show_data("NetKey", 0, net_key, 16);
+ l_info("");
+
+ show_str("Salt Input", 0, keys->salt);
+ show_data("Salt Input", 0, keys->salt, strlen(keys->salt));
+ mesh_crypto_s1(keys->salt, strlen(keys->salt), salt);
+ show_data("s1(Salt)", 0, salt, 16);
+ l_info("");
+
+ show_str("Info", 0, keys->info);
+ show_data("Info", 0, keys->info, strlen(keys->info));
+ l_info("");
+
+ mesh_crypto_aes_cmac(salt, net_key, 16, t);
+ show_data("T", 0, t, 16);
+ l_info("");
+
+ if (memcmp(keys->salt, "nkbk", 4) == 0)
+ mesh_crypto_nkbk(net_key, enc_key);
+ else if (memcmp(keys->salt, "nkpk", 4) == 0)
+ mesh_crypto_nkpk(net_key, enc_key);
+ else if (memcmp(keys->salt, "nkik", 4) == 0)
+ mesh_crypto_nkik(net_key, enc_key);
+
+ verify_data("k1(N, salt, info)", 0, keys->enc_key, enc_key, 16);
+
+ l_info("");
+}
+
+static void check_k1(const struct mesh_crypto_test *keys)
+{
+ uint8_t salt[16];
+ uint8_t info[16];
+ uint8_t t[16];
+ uint8_t okm[16];
+ uint8_t *ikm;
+
+ l_info(COLOR_BLUE "[%s]" COLOR_OFF, keys->name);
+
+ ikm = l_util_from_hexstring(keys->ikm, NULL);
+ show_data("IKM", 0, ikm, 16);
+ l_info("");
+
+ show_str("Salt Input", 0, keys->salt);
+ show_data("Salt Input", 0, keys->salt, strlen(keys->salt));
+ mesh_crypto_s1(keys->salt, strlen(keys->salt), salt);
+ show_data("s1(Salt)", 0, salt, 16);
+ l_info("");
+
+ show_str("Info Input", 0, keys->info);
+ show_data("Info Input", 0, keys->info, strlen(keys->info));
+ mesh_crypto_s1(keys->info, strlen(keys->info), info);
+ show_data("s1(Info)", 0, info, 16);
+ l_info("");
+
+ mesh_crypto_aes_cmac(salt, ikm, 16, t);
+ show_data("T", 0, t, 16);
+ l_info("");
+
+ mesh_crypto_k1(ikm, salt, info, 16, okm);
+
+ verify_data("k1(ikm, salt, info)", 0, keys->okm, okm, 16);
+
+ l_free(ikm);
+ l_info("");
+}
+
+static void check_k2(const struct mesh_crypto_test *keys)
+{
+ uint8_t *net_key;
+ uint8_t p[9];
+ size_t p_len;
+ uint8_t nid;
+ uint8_t enc_key[16];
+ uint8_t priv_key[16];
+
+ l_info(COLOR_BLUE "[%s]" COLOR_OFF, keys->name);
+
+ net_key = l_util_from_hexstring(keys->net_key, NULL);
+ show_data("NetKey", 0, net_key, 16);
+ l_info("");
+
+ if (keys->frnd) {
+ uint8_t *lpn_addr, *fn_addr, *lpn_cntr, *fn_cntr;
+
+ lpn_addr = l_util_from_hexstring(keys->lpn_addr, NULL);
+ fn_addr = l_util_from_hexstring(keys->fn_addr, NULL);
+ lpn_cntr = l_util_from_hexstring(keys->lpn_cntr, NULL);
+ fn_cntr = l_util_from_hexstring(keys->fn_cntr, NULL);
+
+ show_data("LPN Address", 0, lpn_addr, 2);
+ show_data("Friend Address", 0, fn_addr, 2);
+ show_data("LPN Counter", 0, lpn_cntr, 2);
+ show_data("Friend Counter", 0, fn_cntr, 2);
+ l_info("");
+
+ p[0] = 1;
+ l_put_be16(l_get_be16(lpn_addr), p + 1);
+ l_put_be16(l_get_be16(fn_addr), p + 3);
+ l_put_be16(l_get_be16(lpn_cntr), p + 5);
+ l_put_be16(l_get_be16(fn_cntr), p + 7);
+ p_len = 9;
+
+ l_free(fn_cntr);
+ l_free(lpn_cntr);
+ l_free(fn_addr);
+ l_free(lpn_addr);
+ } else {
+ p[0] = 0;
+ p_len = 1;
+ }
+
+ mesh_crypto_k2(net_key, p, p_len, &nid, enc_key, priv_key);
+ verify_data("P", 0, keys->p, p, p_len);
+ l_info("");
+ verify_data("NID", 0, keys->nid, &nid, 1);
+ verify_data("EncryptionKey", 0, keys->enc_key, enc_key, 16);
+ verify_data("PrivacyKey", 0, keys->priv_key, priv_key, 16);
+ l_free(net_key);
+ l_info("");
+}
+
+static void check_k3(const struct mesh_crypto_test *keys)
+{
+ uint8_t *net_key;
+ uint8_t tmp[16];
+ uint8_t short_net_id[8];
+
+ l_info(COLOR_BLUE "[%s]" COLOR_OFF, keys->name);
+
+ net_key = l_util_from_hexstring(keys->net_key, NULL);
+
+ show_data("NetKey", 0, net_key, 16);
+ l_info("");
+
+ show_str("Salt Input", 0, keys->salt);
+ show_data("Salt Input", 0, keys->salt, strlen(keys->salt));
+ mesh_crypto_s1(keys->salt, strlen(keys->salt), tmp);
+ show_data("s1(Salt)", 0, tmp, 16);
+ l_info("");
+
+ show_str("Info", 0, keys->info);
+ show_data("Info", 0, keys->info, strlen(keys->info));
+ l_info("");
+
+ mesh_crypto_aes_cmac(tmp, net_key, 16, tmp);
+ show_data("T", 0, tmp, 16);
+ l_info("");
+
+ mesh_crypto_k3(net_key, short_net_id);
+ verify_data("k3(NetKey)", 0, keys->short_net_id, short_net_id, 8);
+ l_free(net_key);
+ l_info("");
+}
+
+static void check_k4(const struct mesh_crypto_test *keys)
+{
+ uint8_t *app_key;
+ uint8_t tmp[16];
+ uint8_t aid;
+
+ l_info(COLOR_BLUE "[%s]" COLOR_OFF, keys->name);
+
+ app_key = l_util_from_hexstring(keys->app_key, NULL);
+
+ show_data("AppKey", 0, app_key, 16);
+ l_info("");
+
+ show_str("Salt Input", 0, keys->salt);
+ show_data("Salt Input", 0, keys->salt, strlen(keys->salt));
+ mesh_crypto_s1(keys->salt, strlen(keys->salt), tmp);
+ show_data("s1(Salt)", 0, tmp, 16);
+ l_info("");
+
+ show_str("Info", 0, keys->info);
+ show_data("Info", 0, keys->info, strlen(keys->info));
+ l_info("");
+
+ mesh_crypto_aes_cmac(tmp, app_key, 16, tmp);
+ show_data("T", 0, tmp, 16);
+ l_info("");
+
+ mesh_crypto_k4(app_key, &aid);
+ verify_data("k4(AppKey)", 0, keys->aid, &aid, 1);
+ l_free(app_key);
+ l_info("");
+}
+
+int main(int argc, char *argv[])
+{
+ l_log_set_stderr();
+
+ /* Section 8.1 Sample Data Tests */
+ check_s1(&s8_1_1);
+ check_k1(&s8_1_2);
+ check_k2(&s8_1_3);
+ check_k2(&s8_1_4);
+ check_k3(&s8_1_5);
+ check_k4(&s8_1_6);
+
+ /* Section 8.2 Sample Data Tests */
+ check_k4(&s8_2_1);
+ check_k2(&s8_2_2);
+ check_k2(&s8_2_3);
+ check_k3(&s8_2_4);
+ check_k128(&s8_2_5);
+ check_k128(&s8_2_6);
+
+ /* Section 8.3 Sample Data Tests */
+ check_encrypt(&s8_3_1);
+ check_decrypt(&s8_3_1);
+ check_encrypt(&s8_3_2);
+ check_decrypt(&s8_3_2);
+ check_encrypt(&s8_3_3);
+ check_decrypt(&s8_3_3);
+ check_encrypt(&s8_3_4);
+ check_decrypt(&s8_3_4);
+ check_encrypt(&s8_3_5);
+ check_decrypt(&s8_3_5);
+ check_encrypt(&s8_3_6);
+ check_decrypt(&s8_3_6);
+ check_encrypt(&s8_3_7);
+ check_decrypt(&s8_3_7);
+ check_encrypt(&s8_3_8); /* Single segment tester unavailable */
+ check_decrypt(&s8_3_8); /* Single segment tester unavailable */
+ check_encrypt(&s8_3_9);
+ check_decrypt(&s8_3_9);
+ check_encrypt(&s8_3_10);
+ check_decrypt(&s8_3_10);
+ check_encrypt(&s8_3_11); /* Single segment tester unavailable */
+ check_decrypt(&s8_3_11); /* Single segment tester unavailable */
+
+ /* Section 8.4 Beacon Sample Data */
+ check_beacon(&s8_4_3);
+
+ /* Section 8.6 Mesh Proxy Service sample data */
+ check_id_beacon(&s8_6_2);
+
+ return 0;
+}