/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

plugin-runner: Added support for empty string arguments
               Fixed bug where IP:port argument failed
mandos-client: Fixed bug where files wasnt removed after sigterm signal

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
75
75
                                   argp_state, struct argp,
76
76
                                   argp_parse(), ARGP_KEY_ARG,
77
77
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
 
78
#include <signal.h>             /* sigemptyset(), sigaddset(), sigaction(), SIGTERM, sigaction */
78
79
#ifdef __linux__
79
80
#include <sys/klog.h>           /* klogctl() */
80
81
#endif
129
130
  gpgme_ctx_t ctx;
130
131
} mandos_context;
131
132
 
 
133
/* global context so signal handler can reach it*/
 
134
mandos_context mc;
 
135
 
132
136
/*
133
137
 * Make additional room in "buffer" for at least BUFFER_SIZE
134
138
 * additional bytes. "buffer_capacity" is how much is currently
149
153
/* 
150
154
 * Initialize GPGME.
151
155
 */
152
 
static bool init_gpgme(mandos_context *mc, const char *seckey,
 
156
static bool init_gpgme(const char *seckey,
153
157
                       const char *pubkey, const char *tempdir){
154
158
  int ret;
155
159
  gpgme_error_t rc;
176
180
      return false;
177
181
    }
178
182
    
179
 
    rc = gpgme_op_import(mc->ctx, pgp_data);
 
183
    rc = gpgme_op_import(mc.ctx, pgp_data);
180
184
    if(rc != GPG_ERR_NO_ERROR){
181
185
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
182
186
              gpgme_strsource(rc), gpgme_strerror(rc));
225
229
  }
226
230
  
227
231
  /* Create new GPGME "context" */
228
 
  rc = gpgme_new(&(mc->ctx));
 
232
  rc = gpgme_new(&(mc.ctx));
229
233
  if(rc != GPG_ERR_NO_ERROR){
230
234
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
231
235
            gpgme_strsource(rc), gpgme_strerror(rc));
243
247
 * Decrypt OpenPGP data.
244
248
 * Returns -1 on error
245
249
 */
246
 
static ssize_t pgp_packet_decrypt(const mandos_context *mc,
247
 
                                  const char *cryptotext,
 
250
static ssize_t pgp_packet_decrypt(const char *cryptotext,
248
251
                                  size_t crypto_size,
249
252
                                  char **plaintext){
250
253
  gpgme_data_t dh_crypto, dh_plain;
277
280
  
278
281
  /* Decrypt data from the cryptotext data buffer to the plaintext
279
282
     data buffer */
280
 
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
 
283
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
281
284
  if(rc != GPG_ERR_NO_ERROR){
282
285
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
283
286
            gpgme_strsource(rc), gpgme_strerror(rc));
284
287
    plaintext_length = -1;
285
288
    if(debug){
286
289
      gpgme_decrypt_result_t result;
287
 
      result = gpgme_op_decrypt_result(mc->ctx);
 
290
      result = gpgme_op_decrypt_result(mc.ctx);
288
291
      if(result == NULL){
289
292
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
290
293
      } else {
382
385
  fprintf(stderr, "GnuTLS: %s", string);
383
386
}
384
387
 
385
 
static int init_gnutls_global(mandos_context *mc,
386
 
                              const char *pubkeyfilename,
 
388
static int init_gnutls_global(const char *pubkeyfilename,
387
389
                              const char *seckeyfilename){
388
390
  int ret;
389
391
  
407
409
  }
408
410
  
409
411
  /* OpenPGP credentials */
410
 
  gnutls_certificate_allocate_credentials(&mc->cred);
 
412
  gnutls_certificate_allocate_credentials(&mc.cred);
411
413
  if(ret != GNUTLS_E_SUCCESS){
412
414
    fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
413
415
                                                    from
425
427
  }
426
428
  
427
429
  ret = gnutls_certificate_set_openpgp_key_file
428
 
    (mc->cred, pubkeyfilename, seckeyfilename,
 
430
    (mc.cred, pubkeyfilename, seckeyfilename,
429
431
     GNUTLS_OPENPGP_FMT_BASE64);
430
432
  if(ret != GNUTLS_E_SUCCESS){
431
433
    fprintf(stderr,
437
439
  }
438
440
  
439
441
  /* GnuTLS server initialization */
440
 
  ret = gnutls_dh_params_init(&mc->dh_params);
 
442
  ret = gnutls_dh_params_init(&mc.dh_params);
441
443
  if(ret != GNUTLS_E_SUCCESS){
442
444
    fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
443
445
            " %s\n", safer_gnutls_strerror(ret));
444
446
    goto globalfail;
445
447
  }
446
 
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
448
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
447
449
  if(ret != GNUTLS_E_SUCCESS){
448
450
    fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
449
451
            safer_gnutls_strerror(ret));
450
452
    goto globalfail;
451
453
  }
452
454
  
453
 
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
 
455
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
454
456
  
455
457
  return 0;
456
458
  
457
459
 globalfail:
458
460
  
459
 
  gnutls_certificate_free_credentials(mc->cred);
 
461
  gnutls_certificate_free_credentials(mc.cred);
460
462
  gnutls_global_deinit();
461
 
  gnutls_dh_params_deinit(mc->dh_params);
 
463
  gnutls_dh_params_deinit(mc.dh_params);
462
464
  return -1;
463
465
}
464
466
 
465
 
static int init_gnutls_session(mandos_context *mc,
466
 
                               gnutls_session_t *session){
 
467
static int init_gnutls_session(gnutls_session_t *session){
467
468
  int ret;
468
469
  /* GnuTLS session creation */
469
470
  ret = gnutls_init(session, GNUTLS_SERVER);
474
475
  
475
476
  {
476
477
    const char *err;
477
 
    ret = gnutls_priority_set_direct(*session, mc->priority, &err);
 
478
    ret = gnutls_priority_set_direct(*session, mc.priority, &err);
478
479
    if(ret != GNUTLS_E_SUCCESS){
479
480
      fprintf(stderr, "Syntax error at: %s\n", err);
480
481
      fprintf(stderr, "GnuTLS error: %s\n",
485
486
  }
486
487
  
487
488
  ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
488
 
                               mc->cred);
 
489
                               mc.cred);
489
490
  if(ret != GNUTLS_E_SUCCESS){
490
491
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
491
492
            safer_gnutls_strerror(ret));
497
498
  gnutls_certificate_server_set_request(*session,
498
499
                                        GNUTLS_CERT_IGNORE);
499
500
  
500
 
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
 
501
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
501
502
  
502
503
  return 0;
503
504
}
509
510
/* Called when a Mandos server is found */
510
511
static int start_mandos_communication(const char *ip, uint16_t port,
511
512
                                      AvahiIfIndex if_index,
512
 
                                      mandos_context *mc, int af){
 
513
                                      int af){
513
514
  int ret, tcp_sd;
514
515
  ssize_t sret;
515
516
  union {
538
539
    return -1;
539
540
  }
540
541
  
541
 
  ret = init_gnutls_session(mc, &session);
 
542
  ret = init_gnutls_session(&session);
542
543
  if(ret != 0){
543
544
    return -1;
544
545
  }
733
734
  gnutls_bye(session, GNUTLS_SHUT_RDWR);
734
735
  
735
736
  if(buffer_length > 0){
736
 
    decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
 
737
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
737
738
                                               buffer_length,
738
739
                                               &decrypted_buffer);
739
740
    if(decrypted_buffer_size >= 0){
785
786
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
786
787
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
787
788
                             flags,
788
 
                             void* userdata){
789
 
  mandos_context *mc = userdata;
 
789
                             __attribute__((unused)) void* userdata){
790
790
  assert(r);
791
791
  
792
792
  /* Called whenever a service has been resolved successfully or
797
797
  case AVAHI_RESOLVER_FAILURE:
798
798
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
799
799
            " of type '%s' in domain '%s': %s\n", name, type, domain,
800
 
            avahi_strerror(avahi_server_errno(mc->server)));
 
800
            avahi_strerror(avahi_server_errno(mc.server)));
801
801
    break;
802
802
    
803
803
  case AVAHI_RESOLVER_FOUND:
809
809
                PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
810
810
                ip, (intmax_t)interface, port);
811
811
      }
812
 
      int ret = start_mandos_communication(ip, port, interface, mc,
 
812
      int ret = start_mandos_communication(ip, port, interface,
813
813
                                           avahi_proto_to_af(proto));
814
814
      if(ret == 0){
815
 
        avahi_simple_poll_quit(mc->simple_poll);
 
815
        avahi_simple_poll_quit(mc.simple_poll);
816
816
      }
817
817
    }
818
818
  }
828
828
                            const char *domain,
829
829
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
830
830
                            flags,
831
 
                            void* userdata){
832
 
  mandos_context *mc = userdata;
 
831
                            __attribute__((unused)) void* userdata){
833
832
  assert(b);
834
833
  
835
834
  /* Called whenever a new services becomes available on the LAN or
840
839
  case AVAHI_BROWSER_FAILURE:
841
840
    
842
841
    fprintf(stderr, "(Avahi browser) %s\n",
843
 
            avahi_strerror(avahi_server_errno(mc->server)));
844
 
    avahi_simple_poll_quit(mc->simple_poll);
 
842
            avahi_strerror(avahi_server_errno(mc.server)));
 
843
    avahi_simple_poll_quit(mc.simple_poll);
845
844
    return;
846
845
    
847
846
  case AVAHI_BROWSER_NEW:
850
849
       the callback function is called the Avahi server will free the
851
850
       resolver for us. */
852
851
    
853
 
    if(!(avahi_s_service_resolver_new(mc->server, interface,
 
852
    if(!(avahi_s_service_resolver_new(mc.server, interface,
854
853
                                       protocol, name, type, domain,
855
854
                                       AVAHI_PROTO_INET6, 0,
856
 
                                       resolve_callback, mc)))
 
855
                                       resolve_callback, NULL)))
857
856
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
858
 
              name, avahi_strerror(avahi_server_errno(mc->server)));
 
857
              name, avahi_strerror(avahi_server_errno(mc.server)));
859
858
    break;
860
859
    
861
860
  case AVAHI_BROWSER_REMOVE:
870
869
  }
871
870
}
872
871
 
 
872
static void handle_sigterm(__attribute__((unused)) int sig){
 
873
  int old_errno = errno;
 
874
  avahi_simple_poll_quit(mc.simple_poll);
 
875
  errno = old_errno;
 
876
}
 
877
 
873
878
int main(int argc, char *argv[]){
874
879
  AvahiSServiceBrowser *sb = NULL;
875
880
  int error;
889
894
  const char *seckey = PATHDIR "/" SECKEY;
890
895
  const char *pubkey = PATHDIR "/" PUBKEY;
891
896
  
892
 
  mandos_context mc = { .simple_poll = NULL, .server = NULL,
893
 
                        .dh_bits = 1024, .priority = "SECURE256"
894
 
                        ":!CTYPE-X.509:+CTYPE-OPENPGP" };
895
897
  bool gnutls_initialized = false;
896
898
  bool gpgme_initialized = false;
897
899
  double delay = 2.5;
 
900
 
 
901
  struct sigaction old_sigterm_action;
 
902
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
 
903
 
 
904
  /* Initialize mandos context */
 
905
  mc = (mandos_context){ .simple_poll = NULL, .server = NULL,
 
906
                         .dh_bits = 1024, .priority = "SECURE256"
 
907
                         ":!CTYPE-X.509:+CTYPE-OPENPGP" };
898
908
  
899
909
  {
900
910
    struct argp_option options[] = {
1094
1104
    perror("setuid");
1095
1105
  }
1096
1106
  
1097
 
  ret = init_gnutls_global(&mc, pubkey, seckey);
 
1107
  ret = init_gnutls_global(pubkey, seckey);
1098
1108
  if(ret == -1){
1099
1109
    fprintf(stderr, "init_gnutls_global failed\n");
1100
1110
    exitcode = EXIT_FAILURE;
1109
1119
  }
1110
1120
  tempdir_created = true;
1111
1121
  
1112
 
  if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
 
1122
  if(not init_gpgme(pubkey, seckey, tempdir)){
1113
1123
    fprintf(stderr, "init_gpgme failed\n");
1114
1124
    exitcode = EXIT_FAILURE;
1115
1125
    goto end;
1153
1163
    } else {
1154
1164
      af = AF_INET;
1155
1165
    }
1156
 
    ret = start_mandos_communication(address, port, if_index, &mc,
 
1166
    ret = start_mandos_communication(address, port, if_index,
1157
1167
                                     af);
1158
1168
    if(ret < 0){
1159
1169
      exitcode = EXIT_FAILURE;
1207
1217
  /* Create the Avahi service browser */
1208
1218
  sb = avahi_s_service_browser_new(mc.server, if_index,
1209
1219
                                   AVAHI_PROTO_INET6, "_mandos._tcp",
1210
 
                                   NULL, 0, browse_callback, &mc);
 
1220
                                   NULL, 0, browse_callback, NULL);
1211
1221
  if(sb == NULL){
1212
1222
    fprintf(stderr, "Failed to create service browser: %s\n",
1213
1223
            avahi_strerror(avahi_server_errno(mc.server)));
1214
1224
    exitcode = EXIT_FAILURE;
1215
1225
    goto end;
1216
1226
  }
 
1227
 
 
1228
  sigemptyset(&sigterm_action.sa_mask);
 
1229
  ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
 
1230
  if(ret == -1){
 
1231
    perror("sigaddset");
 
1232
    exitcode = EXIT_FAILURE;
 
1233
    goto end;
 
1234
  }
 
1235
  ret = sigaction(SIGTERM, &sigterm_action, &old_sigterm_action);
 
1236
  if(ret == -1){
 
1237
    perror("sigaction");
 
1238
    exitcode = EXIT_FAILURE;
 
1239
    goto end;
 
1240
  }  
1217
1241
  
1218
1242
  /* Run the main loop */
1219
1243