root/net/bluetooth/selftest.c

DEFINITIONS

1. test_ecdh_sample
2. test_ecdh_read
3. test_ecdh
4. test_ecdh
5. run_selftest
6. bt_selftest
7. bt_selftest_init

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3 
   4    Copyright (C) 2014 Intel Corporation
   5 
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License version 2 as
   8    published by the Free Software Foundation;
   9 
  10    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  11    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  12    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  13    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  14    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  15    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18 
  19    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  20    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  21    SOFTWARE IS DISCLAIMED.
  22 */
  23 
  24 #include <linux/debugfs.h>
  25 
  26 #include <net/bluetooth/bluetooth.h>
  27 #include <net/bluetooth/hci_core.h>
  28 
  29 #include "ecdh_helper.h"
  30 #include "smp.h"
  31 #include "selftest.h"
  32 
  33 #if IS_ENABLED(CONFIG_BT_SELFTEST_ECDH)
  34 
  35 static const u8 priv_a_1[32] __initconst = {
  36         0xbd, 0x1a, 0x3c, 0xcd, 0xa6, 0xb8, 0x99, 0x58,
  37         0x99, 0xb7, 0x40, 0xeb, 0x7b, 0x60, 0xff, 0x4a,
  38         0x50, 0x3f, 0x10, 0xd2, 0xe3, 0xb3, 0xc9, 0x74,
  39         0x38, 0x5f, 0xc5, 0xa3, 0xd4, 0xf6, 0x49, 0x3f,
  40 };
  41 static const u8 priv_b_1[32] __initconst = {
  42         0xfd, 0xc5, 0x7f, 0xf4, 0x49, 0xdd, 0x4f, 0x6b,
  43         0xfb, 0x7c, 0x9d, 0xf1, 0xc2, 0x9a, 0xcb, 0x59,
  44         0x2a, 0xe7, 0xd4, 0xee, 0xfb, 0xfc, 0x0a, 0x90,
  45         0x9a, 0xbb, 0xf6, 0x32, 0x3d, 0x8b, 0x18, 0x55,
  46 };
  47 static const u8 pub_a_1[64] __initconst = {
  48         0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
  49         0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
  50         0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
  51         0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20,
  52 
  53         0x8b, 0xd2, 0x89, 0x15, 0xd0, 0x8e, 0x1c, 0x74,
  54         0x24, 0x30, 0xed, 0x8f, 0xc2, 0x45, 0x63, 0x76,
  55         0x5c, 0x15, 0x52, 0x5a, 0xbf, 0x9a, 0x32, 0x63,
  56         0x6d, 0xeb, 0x2a, 0x65, 0x49, 0x9c, 0x80, 0xdc,
  57 };
  58 static const u8 pub_b_1[64] __initconst = {
  59         0x90, 0xa1, 0xaa, 0x2f, 0xb2, 0x77, 0x90, 0x55,
  60         0x9f, 0xa6, 0x15, 0x86, 0xfd, 0x8a, 0xb5, 0x47,
  61         0x00, 0x4c, 0x9e, 0xf1, 0x84, 0x22, 0x59, 0x09,
  62         0x96, 0x1d, 0xaf, 0x1f, 0xf0, 0xf0, 0xa1, 0x1e,
  63 
  64         0x4a, 0x21, 0xb1, 0x15, 0xf9, 0xaf, 0x89, 0x5f,
  65         0x76, 0x36, 0x8e, 0xe2, 0x30, 0x11, 0x2d, 0x47,
  66         0x60, 0x51, 0xb8, 0x9a, 0x3a, 0x70, 0x56, 0x73,
  67         0x37, 0xad, 0x9d, 0x42, 0x3e, 0xf3, 0x55, 0x4c,
  68 };
  69 static const u8 dhkey_1[32] __initconst = {
  70         0x98, 0xa6, 0xbf, 0x73, 0xf3, 0x34, 0x8d, 0x86,
  71         0xf1, 0x66, 0xf8, 0xb4, 0x13, 0x6b, 0x79, 0x99,
  72         0x9b, 0x7d, 0x39, 0x0a, 0xa6, 0x10, 0x10, 0x34,
  73         0x05, 0xad, 0xc8, 0x57, 0xa3, 0x34, 0x02, 0xec,
  74 };
  75 
  76 static const u8 priv_a_2[32] __initconst = {
  77         0x63, 0x76, 0x45, 0xd0, 0xf7, 0x73, 0xac, 0xb7,
  78         0xff, 0xdd, 0x03, 0x72, 0xb9, 0x72, 0x85, 0xb4,
  79         0x41, 0xb6, 0x5d, 0x0c, 0x5d, 0x54, 0x84, 0x60,
  80         0x1a, 0xa3, 0x9a, 0x3c, 0x69, 0x16, 0xa5, 0x06,
  81 };
  82 static const u8 priv_b_2[32] __initconst = {
  83         0xba, 0x30, 0x55, 0x50, 0x19, 0xa2, 0xca, 0xa3,
  84         0xa5, 0x29, 0x08, 0xc6, 0xb5, 0x03, 0x88, 0x7e,
  85         0x03, 0x2b, 0x50, 0x73, 0xd4, 0x2e, 0x50, 0x97,
  86         0x64, 0xcd, 0x72, 0x0d, 0x67, 0xa0, 0x9a, 0x52,
  87 };
  88 static const u8 pub_a_2[64] __initconst = {
  89         0xdd, 0x78, 0x5c, 0x74, 0x03, 0x9b, 0x7e, 0x98,
  90         0xcb, 0x94, 0x87, 0x4a, 0xad, 0xfa, 0xf8, 0xd5,
  91         0x43, 0x3e, 0x5c, 0xaf, 0xea, 0xb5, 0x4c, 0xf4,
  92         0x9e, 0x80, 0x79, 0x57, 0x7b, 0xa4, 0x31, 0x2c,
  93 
  94         0x4f, 0x5d, 0x71, 0x43, 0x77, 0x43, 0xf8, 0xea,
  95         0xd4, 0x3e, 0xbd, 0x17, 0x91, 0x10, 0x21, 0xd0,
  96         0x1f, 0x87, 0x43, 0x8e, 0x40, 0xe2, 0x52, 0xcd,
  97         0xbe, 0xdf, 0x98, 0x38, 0x18, 0x12, 0x95, 0x91,
  98 };
  99 static const u8 pub_b_2[64] __initconst = {
 100         0xcc, 0x00, 0x65, 0xe1, 0xf5, 0x6c, 0x0d, 0xcf,
 101         0xec, 0x96, 0x47, 0x20, 0x66, 0xc9, 0xdb, 0x84,
 102         0x81, 0x75, 0xa8, 0x4d, 0xc0, 0xdf, 0xc7, 0x9d,
 103         0x1b, 0x3f, 0x3d, 0xf2, 0x3f, 0xe4, 0x65, 0xf4,
 104 
 105         0x79, 0xb2, 0xec, 0xd8, 0xca, 0x55, 0xa1, 0xa8,
 106         0x43, 0x4d, 0x6b, 0xca, 0x10, 0xb0, 0xc2, 0x01,
 107         0xc2, 0x33, 0x4e, 0x16, 0x24, 0xc4, 0xef, 0xee,
 108         0x99, 0xd8, 0xbb, 0xbc, 0x48, 0xd0, 0x01, 0x02,
 109 };
 110 static const u8 dhkey_2[32] __initconst = {
 111         0x69, 0xeb, 0x21, 0x32, 0xf2, 0xc6, 0x05, 0x41,
 112         0x60, 0x19, 0xcd, 0x5e, 0x94, 0xe1, 0xe6, 0x5f,
 113         0x33, 0x07, 0xe3, 0x38, 0x4b, 0x68, 0xe5, 0x62,
 114         0x3f, 0x88, 0x6d, 0x2f, 0x3a, 0x84, 0x85, 0xab,
 115 };
 116 
 117 static const u8 priv_a_3[32] __initconst = {
 118         0xbd, 0x1a, 0x3c, 0xcd, 0xa6, 0xb8, 0x99, 0x58,
 119         0x99, 0xb7, 0x40, 0xeb, 0x7b, 0x60, 0xff, 0x4a,
 120         0x50, 0x3f, 0x10, 0xd2, 0xe3, 0xb3, 0xc9, 0x74,
 121         0x38, 0x5f, 0xc5, 0xa3, 0xd4, 0xf6, 0x49, 0x3f,
 122 };
 123 static const u8 pub_a_3[64] __initconst = {
 124         0xe6, 0x9d, 0x35, 0x0e, 0x48, 0x01, 0x03, 0xcc,
 125         0xdb, 0xfd, 0xf4, 0xac, 0x11, 0x91, 0xf4, 0xef,
 126         0xb9, 0xa5, 0xf9, 0xe9, 0xa7, 0x83, 0x2c, 0x5e,
 127         0x2c, 0xbe, 0x97, 0xf2, 0xd2, 0x03, 0xb0, 0x20,
 128 
 129         0x8b, 0xd2, 0x89, 0x15, 0xd0, 0x8e, 0x1c, 0x74,
 130         0x24, 0x30, 0xed, 0x8f, 0xc2, 0x45, 0x63, 0x76,
 131         0x5c, 0x15, 0x52, 0x5a, 0xbf, 0x9a, 0x32, 0x63,
 132         0x6d, 0xeb, 0x2a, 0x65, 0x49, 0x9c, 0x80, 0xdc,
 133 };
 134 static const u8 dhkey_3[32] __initconst = {
 135         0x2d, 0xab, 0x00, 0x48, 0xcb, 0xb3, 0x7b, 0xda,
 136         0x55, 0x7b, 0x8b, 0x72, 0xa8, 0x57, 0x87, 0xc3,
 137         0x87, 0x27, 0x99, 0x32, 0xfc, 0x79, 0x5f, 0xae,
 138         0x7c, 0x1c, 0xf9, 0x49, 0xe6, 0xd7, 0xaa, 0x70,
 139 };
 140 
 141 static int __init test_ecdh_sample(struct crypto_kpp *tfm, const u8 priv_a[32],
 142                                    const u8 priv_b[32], const u8 pub_a[64],
 143                                    const u8 pub_b[64], const u8 dhkey[32])
 144 {
 145         u8 *tmp, *dhkey_a, *dhkey_b;
 146         int ret;
 147 
 148         tmp = kmalloc(64, GFP_KERNEL);
 149         if (!tmp)
 150                 return -EINVAL;
 151 
 152         dhkey_a = &tmp[0];
 153         dhkey_b = &tmp[32];
 154 
 155         ret = set_ecdh_privkey(tfm, priv_a);
 156         if (ret)
 157                 goto out;
 158 
 159         ret = compute_ecdh_secret(tfm, pub_b, dhkey_a);
 160         if (ret)
 161                 goto out;
 162 
 163         if (memcmp(dhkey_a, dhkey, 32)) {
 164                 ret = -EINVAL;
 165                 goto out;
 166         }
 167 
 168         ret = set_ecdh_privkey(tfm, priv_b);
 169         if (ret)
 170                 goto out;
 171 
 172         ret = compute_ecdh_secret(tfm, pub_a, dhkey_b);
 173         if (ret)
 174                 goto out;
 175 
 176         if (memcmp(dhkey_b, dhkey, 32))
 177                 ret = -EINVAL;
 178         /* fall through*/
 179 out:
 180         kfree(tmp);
 181         return ret;
 182 }
 183 
 184 static char test_ecdh_buffer[32];
 185 
 186 static ssize_t test_ecdh_read(struct file *file, char __user *user_buf,
 187                               size_t count, loff_t *ppos)
 188 {
 189         return simple_read_from_buffer(user_buf, count, ppos, test_ecdh_buffer,
 190                                        strlen(test_ecdh_buffer));
 191 }
 192 
 193 static const struct file_operations test_ecdh_fops = {
 194         .open           = simple_open,
 195         .read           = test_ecdh_read,
 196         .llseek         = default_llseek,
 197 };
 198 
 199 static int __init test_ecdh(void)
 200 {
 201         struct crypto_kpp *tfm;
 202         ktime_t calltime, delta, rettime;
 203         unsigned long long duration = 0;
 204         int err;
 205 
 206         calltime = ktime_get();
 207 
 208         tfm = crypto_alloc_kpp("ecdh", CRYPTO_ALG_INTERNAL, 0);
 209         if (IS_ERR(tfm)) {
 210                 BT_ERR("Unable to create ECDH crypto context");
 211                 err = PTR_ERR(tfm);
 212                 goto done;
 213         }
 214 
 215         err = test_ecdh_sample(tfm, priv_a_1, priv_b_1, pub_a_1, pub_b_1,
 216                                dhkey_1);
 217         if (err) {
 218                 BT_ERR("ECDH sample 1 failed");
 219                 goto done;
 220         }
 221 
 222         err = test_ecdh_sample(tfm, priv_a_2, priv_b_2, pub_a_2, pub_b_2,
 223                                dhkey_2);
 224         if (err) {
 225                 BT_ERR("ECDH sample 2 failed");
 226                 goto done;
 227         }
 228 
 229         err = test_ecdh_sample(tfm, priv_a_3, priv_a_3, pub_a_3, pub_a_3,
 230                                dhkey_3);
 231         if (err) {
 232                 BT_ERR("ECDH sample 3 failed");
 233                 goto done;
 234         }
 235 
 236         crypto_free_kpp(tfm);
 237 
 238         rettime = ktime_get();
 239         delta = ktime_sub(rettime, calltime);
 240         duration = (unsigned long long) ktime_to_ns(delta) >> 10;
 241 
 242         BT_INFO("ECDH test passed in %llu usecs", duration);
 243 
 244 done:
 245         if (!err)
 246                 snprintf(test_ecdh_buffer, sizeof(test_ecdh_buffer),
 247                          "PASS (%llu usecs)\n", duration);
 248         else
 249                 snprintf(test_ecdh_buffer, sizeof(test_ecdh_buffer), "FAIL\n");
 250 
 251         debugfs_create_file("selftest_ecdh", 0444, bt_debugfs, NULL,
 252                             &test_ecdh_fops);
 253 
 254         return err;
 255 }
 256 
 257 #else
 258 
 259 static inline int test_ecdh(void)
 260 {
 261         return 0;
 262 }
 263 
 264 #endif
 265 
 266 static int __init run_selftest(void)
 267 {
 268         int err;
 269 
 270         BT_INFO("Starting self testing");
 271 
 272         err = test_ecdh();
 273         if (err)
 274                 goto done;
 275 
 276         err = bt_selftest_smp();
 277 
 278 done:
 279         BT_INFO("Finished self testing");
 280 
 281         return err;
 282 }
 283 
 284 #if IS_MODULE(CONFIG_BT)
 285 
 286 /* This is run when CONFIG_BT_SELFTEST=y and CONFIG_BT=m and is just a
 287  * wrapper to allow running this at module init.
 288  *
 289  * If CONFIG_BT_SELFTEST=n, then this code is not compiled at all.
 290  */
 291 int __init bt_selftest(void)
 292 {
 293         return run_selftest();
 294 }
 295 
 296 #else
 297 
 298 /* This is run when CONFIG_BT_SELFTEST=y and CONFIG_BT=y and is run
 299  * via late_initcall() as last item in the initialization sequence.
 300  *
 301  * If CONFIG_BT_SELFTEST=n, then this code is not compiled at all.
 302  */
 303 static int __init bt_selftest_init(void)
 304 {
 305         return run_selftest();
 306 }
 307 late_initcall(bt_selftest_init);
 308 
 309 #endif