/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to plugins.d/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2009-09-05 01:46:42 UTC
  • Revision ID: teddy@fukt.bsnet.se-20090905014642-36108sqop1ci0z0m
* plugins.d/mandos-client.c (start_mandos_communication): Check
                                                         "quit_now"
                                                         throughout.
                                                         Always close
                                                         socket and
                                                         deinit GnuTLS
                                                         properly.
  (browse_callback): Return immediately if "quit_now" is set.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
71
71
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN
72
72
                                */
73
73
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
74
 
                                   getuid(), getgid(), seteuid(),
 
74
                                   getuid(), getgid(), setuid(),
75
75
                                   setgid() */
76
76
#include <arpa/inet.h>          /* inet_pton(), htons */
77
77
#include <iso646.h>             /* not, or, and */
164
164
 */
165
165
static bool init_gpgme(const char *seckey,
166
166
                       const char *pubkey, const char *tempdir){
 
167
  int ret;
167
168
  gpgme_error_t rc;
168
169
  gpgme_engine_info_t engine_info;
169
170
  
172
173
   * Helper function to insert pub and seckey to the engine keyring.
173
174
   */
174
175
  bool import_key(const char *filename){
175
 
    int ret;
176
176
    int fd;
177
177
    gpgme_data_t pgp_data;
178
178
    
474
474
static int init_gnutls_session(gnutls_session_t *session){
475
475
  int ret;
476
476
  /* GnuTLS session creation */
477
 
  do {
478
 
    ret = gnutls_init(session, GNUTLS_SERVER);
479
 
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
477
  ret = gnutls_init(session, GNUTLS_SERVER);
480
478
  if(ret != GNUTLS_E_SUCCESS){
481
479
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
482
480
            safer_gnutls_strerror(ret));
484
482
  
485
483
  {
486
484
    const char *err;
487
 
    do {
488
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
489
 
    } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
485
    ret = gnutls_priority_set_direct(*session, mc.priority, &err);
490
486
    if(ret != GNUTLS_E_SUCCESS){
491
487
      fprintf(stderr, "Syntax error at: %s\n", err);
492
488
      fprintf(stderr, "GnuTLS error: %s\n",
496
492
    }
497
493
  }
498
494
  
499
 
  do {
500
 
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
501
 
                                 mc.cred);
502
 
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
495
  ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
496
                               mc.cred);
503
497
  if(ret != GNUTLS_E_SUCCESS){
504
498
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
505
499
            safer_gnutls_strerror(ret));
508
502
  }
509
503
  
510
504
  /* ignore client certificate if any. */
511
 
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
 
505
  gnutls_certificate_server_set_request(*session,
 
506
                                        GNUTLS_CERT_IGNORE);
512
507
  
513
508
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
514
509
  
536
531
  char *decrypted_buffer;
537
532
  size_t buffer_length = 0;
538
533
  size_t buffer_capacity = 0;
 
534
  ssize_t decrypted_buffer_size;
539
535
  size_t written;
540
536
  int retval = 0;
541
537
  gnutls_session_t session;
716
712
    goto mandos_end;
717
713
  }
718
714
  
719
 
  do {
 
715
  do{
720
716
    ret = gnutls_handshake(session);
721
717
    if(quit_now){
722
718
      goto mandos_end;
768
764
      case GNUTLS_E_AGAIN:
769
765
        break;
770
766
      case GNUTLS_E_REHANDSHAKE:
771
 
        do {
 
767
        do{
772
768
          ret = gnutls_handshake(session);
773
769
          
774
770
          if(quit_now){
809
805
  }
810
806
  
811
807
  if(buffer_length > 0){
812
 
    ssize_t decrypted_buffer_size;
813
808
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
814
809
                                               buffer_length,
815
810
                                               &decrypted_buffer);
816
811
    if(decrypted_buffer_size >= 0){
817
 
      
818
812
      written = 0;
819
813
      while(written < (size_t) decrypted_buffer_size){
820
814
        if(quit_now){
1000
994
  bool gpgme_initialized = false;
1001
995
  float delay = 2.5f;
1002
996
  
1003
 
  struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
 
997
  struct sigaction old_sigterm_action;
1004
998
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1005
999
  
1006
 
  uid = getuid();
1007
 
  gid = getgid();
1008
 
  
1009
 
  /* Lower any group privileges we might have, just to be safe */
1010
 
  errno = 0;
1011
 
  ret = setgid(gid);
1012
 
  if(ret == -1){
1013
 
    perror("setgid");
1014
 
  }
1015
 
  
1016
 
  /* Lower user privileges (temporarily) */
1017
 
  errno = 0;
1018
 
  ret = seteuid(uid);
1019
 
  if(ret == -1){
1020
 
    perror("seteuid");
1021
 
  }
1022
 
  
1023
 
  if(quit_now){
1024
 
    goto end;
1025
 
  }
1026
 
  
1027
1000
  {
1028
1001
    struct argp_option options[] = {
1029
1002
      { .name = "debug", .key = 128,
1213
1186
      goto end;
1214
1187
    }
1215
1188
    
1216
 
    /* Re-raise priviliges */
1217
 
    errno = 0;
1218
 
    ret = seteuid(0);
1219
 
    if(ret == -1){
1220
 
      perror("seteuid");
1221
 
    }
1222
 
    
1223
1189
#ifdef __linux__
1224
1190
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1225
1191
       messages to mess up the prompt */
1243
1209
        }
1244
1210
      }
1245
1211
#endif  /* __linux__ */
1246
 
      /* Lower privileges */
1247
 
      errno = 0;
1248
 
      ret = seteuid(uid);
1249
 
      if(ret == -1){
1250
 
        perror("seteuid");
1251
 
      }
1252
1212
      goto end;
1253
1213
    }
1254
1214
    strcpy(network.ifr_name, interface);
1264
1224
      }
1265
1225
#endif  /* __linux__ */
1266
1226
      exitcode = EXIT_FAILURE;
1267
 
      /* Lower privileges */
1268
 
      errno = 0;
1269
 
      ret = seteuid(uid);
1270
 
      if(ret == -1){
1271
 
        perror("seteuid");
1272
 
      }
1273
1227
      goto end;
1274
1228
    }
1275
1229
    if((network.ifr_flags & IFF_UP) == 0){
1288
1242
          }
1289
1243
        }
1290
1244
#endif  /* __linux__ */
1291
 
        /* Lower privileges */
1292
 
        errno = 0;
1293
 
        ret = seteuid(uid);
1294
 
        if(ret == -1){
1295
 
          perror("seteuid");
1296
 
        }
1297
1245
        goto end;
1298
1246
      }
1299
1247
    }
1327
1275
      }
1328
1276
    }
1329
1277
#endif  /* __linux__ */
1330
 
    /* Lower privileges */
1331
 
    errno = 0;
1332
 
    if(take_down_interface){
1333
 
      /* Lower privileges */
1334
 
      ret = seteuid(uid);
1335
 
      if(ret == -1){
1336
 
        perror("seteuid");
1337
 
      }
1338
 
    } else {
1339
 
      /* Lower privileges permanently */
1340
 
      ret = setuid(uid);
1341
 
      if(ret == -1){
1342
 
        perror("setuid");
1343
 
      }
1344
 
    }
 
1278
  }
 
1279
  
 
1280
  if(quit_now){
 
1281
    goto end;
 
1282
  }
 
1283
  
 
1284
  uid = getuid();
 
1285
  gid = getgid();
 
1286
  
 
1287
  errno = 0;
 
1288
  setgid(gid);
 
1289
  if(ret == -1){
 
1290
    perror("setgid");
 
1291
  }
 
1292
  
 
1293
  ret = setuid(uid);
 
1294
  if(ret == -1){
 
1295
    perror("setuid");
1345
1296
  }
1346
1297
  
1347
1298
  if(quit_now){
1521
1472
  
1522
1473
  /* Take down the network interface */
1523
1474
  if(take_down_interface){
1524
 
    /* Re-raise priviliges */
1525
 
    errno = 0;
1526
 
    ret = seteuid(0);
 
1475
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1527
1476
    if(ret == -1){
1528
 
      perror("seteuid");
 
1477
      perror("ioctl SIOCGIFFLAGS");
 
1478
    } else if(network.ifr_flags & IFF_UP) {
 
1479
      network.ifr_flags &= ~IFF_UP; /* clear flag */
 
1480
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1481
      if(ret == -1){
 
1482
        perror("ioctl SIOCSIFFLAGS");
 
1483
      }
1529
1484
    }
1530
 
    if(geteuid() == 0){
1531
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1532
 
      if(ret == -1){
1533
 
        perror("ioctl SIOCGIFFLAGS");
1534
 
      } else if(network.ifr_flags & IFF_UP) {
1535
 
        network.ifr_flags &= ~IFF_UP; /* clear flag */
1536
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
1537
 
        if(ret == -1){
1538
 
          perror("ioctl SIOCSIFFLAGS");
1539
 
        }
1540
 
      }
1541
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1542
 
      if(ret == -1){
1543
 
        perror("close");
1544
 
      }
1545
 
      /* Lower privileges permanently */
1546
 
      errno = 0;
1547
 
      ret = setuid(uid);
1548
 
      if(ret == -1){
1549
 
        perror("setuid");
1550
 
      }
 
1485
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1486
    if(ret == -1){
 
1487
      perror("close");
1551
1488
    }
1552
1489
  }
1553
1490