package/ead/src/ead-client.c

   1 /*
   2  * Client for the Emergency Access Daemon
   3  * Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <sys/types.h>
  16 #include <sys/socket.h>
  17 #include <sys/time.h>
  18 #include <netinet/in.h>
  19 #include <stdio.h>
  20 #include <stddef.h>
  21 #include <stdint.h>
  22 #include <stdlib.h>
  23 #include <stdbool.h>
  24 #include <string.h>
  25 #include <fcntl.h>
  26 #include <unistd.h>
  27 #include <t_pwd.h>
  28 #include <t_read.h>
  29 #include <t_sha.h>
  30 #include <t_defines.h>
  31 #include <t_client.h>
  32 #include "ead.h"
  33 #include "ead-crypt.h"
  34
  35 #include "pw_encrypt_md5.c"
  36
  37 #define EAD_TIMEOUT     400
  38 #define EAD_TIMEOUT_LONG 2000
  39
  40 static char msgbuf[1500];
  41 static struct ead_msg *msg = (struct ead_msg *) msgbuf;
  42 static uint16_t nid = 0xffff;
  43 struct sockaddr_in local, remote;
  44 static int s = 0;
  45 static int sockflags;
  46
  47 static unsigned char *skey = NULL;
  48 static unsigned char bbuf[MAXPARAMLEN];
  49 static unsigned char saltbuf[MAXSALTLEN];
  50 static char *username = NULL;
  51 static char password[MAXPARAMLEN] = "";
  52 static char pw_md5[MD5_OUT_BUFSIZE];
  53 static char pw_salt[MAXSALTLEN];
  54
  55 static struct t_client *tc = NULL;
  56 static struct t_num salt = { .data = saltbuf };
  57 static struct t_num *A, B;
  58 static struct t_preconf *tcp;
  59 static int auth_type = EAD_AUTH_DEFAULT;
  60 static int timeout = EAD_TIMEOUT;
  61
  62 static void
  63 set_nonblock(int enable)
  64 {
  65         if (enable == !!(sockflags & O_NONBLOCK));
  66                 return;
  67
  68         sockflags ^= O_NONBLOCK;
  69         fcntl(s, F_SETFL, sockflags);
  70 }
  71
  72 static int
  73 send_packet(int type, bool (*handler)(void), unsigned int max)
  74 {
  75         struct timeval tv;
  76         fd_set fds;
  77         int nfds;
  78         int len;
  79         int res = 0;
  80
  81         type = htonl(type);
  82         set_nonblock(0);
  83         sendto(s, msgbuf, sizeof(struct ead_msg) + ntohl(msg->len), 0, (struct sockaddr *) &remote, sizeof(remote));
  84         set_nonblock(1);
  85
  86         tv.tv_sec = timeout / 1000;
  87         tv.tv_usec = (timeout % 1000) * 1000;
  88
  89         FD_ZERO(&fds);
  90         do {
  91                 FD_SET(s, &fds);
  92                 nfds = select(s + 1, &fds, NULL, NULL, &tv);
  93
  94                 if (nfds <= 0)
  95                         break;
  96
  97                 if (!FD_ISSET(s, &fds))
  98                         break;
  99
 100                 len = read(s, msgbuf, sizeof(msgbuf));
 101                 if (len < 0)
 102                         break;
 103
 104                 if (len < sizeof(struct ead_msg))
 105                         continue;
 106
 107                 if (len < sizeof(struct ead_msg) + ntohl(msg->len))
 108                         continue;
 109
 110                 if (msg->magic != htonl(EAD_MAGIC))
 111                         continue;
 112
 113                 if ((nid != 0xffff) && (ntohs(msg->nid) != nid))
 114                         continue;
 115
 116                 if (msg->type != type)
 117                         continue;
 118
 119                 if (handler())
 120                         res++;
 121
 122                 if ((max > 0) && (res >= max))
 123                         break;
 124         } while (1);
 125
 126         return res;
 127 }
 128
 129 static void
 130 prepare_password(void)
 131 {
 132         switch(auth_type) {
 133         case EAD_AUTH_DEFAULT:
 134                 break;
 135         case EAD_AUTH_MD5:
 136                 md5_crypt(pw_md5, (unsigned char *) password, (unsigned char *) pw_salt);
 137                 strncpy(password, pw_md5, sizeof(password));
 138                 break;
 139         }
 140 }
 141
 142 static bool
 143 handle_pong(void)
 144 {
 145         struct ead_msg_pong *pong = EAD_DATA(msg, pong);
 146         int len = ntohl(msg->len) - sizeof(struct ead_msg_pong);
 147
 148         if (len <= 0)
 149                 return false;
 150
 151         pong->name[len] = 0;
 152         auth_type = ntohs(pong->auth_type);
 153         if (nid == 0xffff)
 154                 printf("%04x: %s\n", ntohs(msg->nid), pong->name);
 155         return true;
 156 }
 157
 158 static bool
 159 handle_prime(void)
 160 {
 161         struct ead_msg_salt *sb = EAD_DATA(msg, salt);
 162
 163         salt.len = sb->len;
 164         memcpy(salt.data, sb->salt, salt.len);
 165
 166         if (auth_type == EAD_AUTH_MD5) {
 167                 memcpy(pw_salt, sb->ext_salt, MAXSALTLEN);
 168                 pw_salt[MAXSALTLEN - 1] = 0;
 169         }
 170
 171         tcp = t_getpreparam(sb->prime);
 172         tc = t_clientopen(username, &tcp->modulus, &tcp->generator, &salt);
 173         if (!tc) {
 174                 fprintf(stderr, "Client open failed\n");
 175                 return false;
 176         }
 177
 178         return true;
 179 }
 180
 181 static bool
 182 handle_b(void)
 183 {
 184         struct ead_msg_number *num = EAD_DATA(msg, number);
 185         int len = ntohl(msg->len) - sizeof(struct ead_msg_number);
 186
 187         B.data = bbuf;
 188         B.len = len;
 189         memcpy(bbuf, num->data, len);
 190         return true;
 191 }
 192
 193 static bool
 194 handle_none(void)
 195 {
 196         return true;
 197 }
 198
 199 static bool
 200 handle_done_auth(void)
 201 {
 202         struct ead_msg_auth *auth = EAD_DATA(msg, auth);
 203         if (t_clientverify(tc, auth->data) != 0) {
 204                 fprintf(stderr, "Client auth verify failed\n");
 205                 return false;
 206         }
 207         return true;
 208 }
 209
 210 static bool
 211 handle_cmd_data(void)
 212 {
 213         struct ead_msg_cmd_data *cmd = EAD_ENC_DATA(msg, cmd_data);
 214         int datalen = ead_decrypt_message(msg) - sizeof(struct ead_msg_cmd_data);
 215
 216         if (datalen < 0)
 217                 return false;
 218
 219         if (datalen > 0) {
 220                 write(1, cmd->data, datalen);
 221         }
 222
 223         return !!cmd->done;
 224 }
 225 static int
 226 send_ping(void)
 227 {
 228         msg->type = htonl(EAD_TYPE_PING);
 229         msg->len = 0;
 230         return send_packet(EAD_TYPE_PONG, handle_pong, (nid == 0xffff ? 0 : 1));
 231 }
 232
 233 static int
 234 send_username(void)
 235 {
 236         msg->type = htonl(EAD_TYPE_SET_USERNAME);
 237         msg->len = htonl(sizeof(struct ead_msg_user));
 238         strcpy(EAD_DATA(msg, user)->username, username);
 239         return send_packet(EAD_TYPE_ACK_USERNAME, handle_none, 1);
 240 }
 241
 242 static int
 243 get_prime(void)
 244 {
 245         msg->type = htonl(EAD_TYPE_GET_PRIME);
 246         msg->len = 0;
 247         return send_packet(EAD_TYPE_PRIME, handle_prime, 1);
 248 }
 249
 250 static int
 251 send_a(void)
 252 {
 253         struct ead_msg_number *num = EAD_DATA(msg, number);
 254         A = t_clientgenexp(tc);
 255         msg->type = htonl(EAD_TYPE_SEND_A);
 256         msg->len = htonl(sizeof(struct ead_msg_number) + A->len);
 257         memcpy(num->data, A->data, A->len);
 258         return send_packet(EAD_TYPE_SEND_B, handle_b, 1);
 259 }
 260
 261 static int
 262 send_auth(void)
 263 {
 264         struct ead_msg_auth *auth = EAD_DATA(msg, auth);
 265
 266         prepare_password();
 267         t_clientpasswd(tc, password);
 268         skey = t_clientgetkey(tc, &B);
 269         if (!skey)
 270                 return 0;
 271
 272         ead_set_key(skey);
 273         msg->type = htonl(EAD_TYPE_SEND_AUTH);
 274         msg->len = htonl(sizeof(struct ead_msg_auth));
 275         memcpy(auth->data, t_clientresponse(tc), sizeof(auth->data));
 276         return send_packet(EAD_TYPE_DONE_AUTH, handle_done_auth, 1);
 277 }
 278
 279 static int
 280 send_command(const char *command)
 281 {
 282         struct ead_msg_cmd *cmd = EAD_ENC_DATA(msg, cmd);
 283
 284         msg->type = htonl(EAD_TYPE_SEND_CMD);
 285         cmd->type = htons(EAD_CMD_NORMAL);
 286         cmd->timeout = htons(10);
 287         strncpy((char *)cmd->data, command, 1024);
 288         ead_encrypt_message(msg, sizeof(struct ead_msg_cmd) + strlen(command) + 1);
 289         return send_packet(EAD_TYPE_RESULT_CMD, handle_cmd_data, 1);
 290 }
 291
 292
 293 static int
 294 usage(const char *prog)
 295 {
 296         fprintf(stderr, "Usage: %s <node> <username>[:<password>]\n"
 297                 "\n"
 298                 "\n<node>:     Node ID (4 digits hex)\n"
 299                 "\n<username>: Username to authenticate with\n"
 300                 "\n"
 301                 "\nPassing no arguments shows a list of active nodes on the network\n"
 302                 "\n", prog);
 303         return -1;
 304 }
 305
 306
 307 int main(int argc, char **argv)
 308 {
 309         int val = 1;
 310         char *st = NULL;
 311         const char *command = NULL;
 312
 313         msg->magic = htonl(EAD_MAGIC);
 314         msg->tid = 0;
 315
 316         memset(&local, 0, sizeof(local));
 317         memset(&remote, 0, sizeof(remote));
 318
 319         remote.sin_family = AF_INET;
 320         remote.sin_addr.s_addr = 0xffffffff;
 321         remote.sin_port = htons(EAD_PORT);
 322
 323         local.sin_family = AF_INET;
 324         local.sin_addr.s_addr = INADDR_ANY;
 325         local.sin_port = 0;
 326
 327         switch(argc) {
 328         case 4:
 329                 command = argv[3];
 330                 /* fall through */
 331         case 3:
 332                 username = argv[2];
 333                 st = strchr(username, ':');
 334                 if (st) {
 335                         *st = 0;
 336                         st++;
 337                         strncpy(password, st, sizeof(password));
 338                         password[sizeof(password) - 1] = 0;
 339                         /* hide command line password */
 340                         memset(st, 0, strlen(st));
 341                 }
 342                 /* fall through */
 343         case 2:
 344                 nid = strtoul(argv[1], &st, 16);
 345                 if (st && st[0] != 0)
 346                         return usage(argv[0]);
 347                 /* fall through */
 348         case 1:
 349                 break;
 350         default:
 351                 return usage(argv[0]);
 352         }
 353
 354         msg->nid = htons(nid);
 355         s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 356         if (s < 0) {
 357                 perror("socket");
 358                 return -1;
 359         }
 360
 361         setsockopt(s, SOL_SOCKET, SO_BROADCAST, &val, sizeof(val));
 362
 363         if (bind(s, (struct sockaddr *)&local, sizeof(local)) < 0) {
 364                 perror("bind");
 365                 return -1;
 366         }
 367         sockflags = fcntl(s, F_GETFL);
 368
 369         if (!send_ping()) {
 370                 fprintf(stderr, "No devices found\n");
 371                 return 1;
 372         }
 373
 374         if (nid == 0xffff)
 375                 return 0;
 376
 377         if (!username || !password[0])
 378                 return 0;
 379
 380         if (!send_username()) {
 381                 fprintf(stderr, "Device did not accept user name\n");
 382                 return 1;
 383         }
 384         if (!get_prime()) {
 385                 fprintf(stderr, "Failed to get user password info\n");
 386                 return 1;
 387         }
 388
 389         timeout = EAD_TIMEOUT_LONG;
 390         if (!send_a()) {
 391                 fprintf(stderr, "Failed to send local authentication data\n");
 392                 return 1;
 393         }
 394         if (!send_auth()) {
 395                 fprintf(stderr, "Authentication failed\n");
 396                 return 1;
 397         }
 398         if (!command) {
 399                 fprintf(stderr, "Authentication succesful\n");
 400                 return 0;
 401         }
 402         if (!send_command(command)) {
 403                 fprintf(stderr, "Command failed\n");
 404                 return 1;
 405         }
 406
 407         return 0;
 408 }