source3/utils/smbta-util.c

   1 /*
   2    smbta-util: tool for controlling encryption with
   3         vfs_smb_traffic_analyzer
   4    Copyright (C) 2010 Holger Hetterich <hhetter@novell.com>
   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 as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "includes.h"
  20 #include "secrets.h"
  21
  22 static void delete_key(void);
  23
  24
  25 static void help(void)
  26 {
  27 printf("-h              print this help message.\n");
  28 printf("-f <file>       install the key from a file and activate\n");
  29 printf("                encryption.\n");
  30 printf("-g <file>       generate a key, save it to a file, and activate encryption.\n");
  31 printf("-u              uninstall a key, and deactivate encryption.\n");
  32 printf("-c <file>       create a file from an installed key.\n");
  33 printf("-s              check if a key is installed, and print the key to stdout.\n");
  34 printf("\n");
  35 }
  36
  37 static void check_key(void)
  38 {       size_t size;
  39         char *akey;
  40         if (!secrets_init()) {
  41                 printf("Error opening secrets database.");
  42                 exit(1);
  43         }
  44         akey = (char *) secrets_fetch("smb_traffic_analyzer_key", &size);
  45         if (akey != NULL) {
  46                 printf("A key is installed: %s\n",akey);
  47                 printf("Encryption activated.\n");
  48                 free(akey);
  49                 exit(0);
  50         } else printf("No key is installed.\n");
  51         exit(1);
  52 }
  53
  54 static void create_keyfile(char *filename, char *key)
  55 {
  56         FILE *keyfile;
  57         keyfile = fopen(filename, "w");
  58         if (keyfile == NULL) {
  59                 printf("error creating the keyfile!\n");
  60                 exit(1);
  61         }
  62         fprintf(keyfile, "%s", key);
  63         fclose(keyfile);
  64         printf("File '%s' has been created.\n", filename);
  65 }
  66
  67 /**
  68  * Load a key from a file. The caller has to free the
  69  * returned string.
  70  */
  71 static void load_key_from_file(char *filename, char *key)
  72 {
  73         FILE *keyfile;
  74         int l;
  75         keyfile = fopen(filename, "r");
  76         if (keyfile == NULL) {
  77                 printf("Error opening the keyfile!\n");
  78                 exit(1);
  79         }
  80         l = fscanf(keyfile, "%s", key);
  81         if (l != 1 || strlen(key) != 16) {
  82                 printf("Key file in wrong format\n");
  83                 fclose(keyfile);
  84                 exit(1);
  85         }
  86         fclose(keyfile);
  87 }
  88
  89 static void create_file_from_key(char *filename)
  90 {
  91         size_t size;
  92         char *akey = (char *) secrets_fetch("smb_traffic_analyzer_key", &size);
  93         if (akey == NULL) {
  94                 printf("No key is installed! Can't create file.\n");
  95                 exit(1);
  96         }
  97         create_keyfile(filename, akey);
  98         free(akey);
  99 }
 100
 101 /**
 102  * Generate a random key. The user has to free the returned
 103  * string.
 104  */
 105 static void generate_key(char *key)
 106 {
 107         int f;
 108         srand( (unsigned)time( NULL ) );
 109         for ( f = 0; f < 16; f++) {
 110                 *(key+f) = (rand() % 128) +32;
 111         }
 112         *(key+16)='\0';
 113         printf("Random key generated.\n");
 114 }
 115
 116 static void create_new_key_and_activate( char *filename )
 117 {
 118         char key[17] = {0};
 119
 120         if (!secrets_init()) {
 121                 printf("Error opening secrets database.");
 122                 exit(1);
 123         }
 124
 125         generate_key(key);
 126         delete_key();
 127         secrets_store("smb_traffic_analyzer_key", key, strlen(key)+1 );
 128         printf("Key installed, encryption activated.\n");
 129         create_file_from_key(filename);
 130 }
 131
 132 static void delete_key(void)
 133 {
 134         size_t size;
 135         char *akey = (char *) secrets_fetch("smb_traffic_analyzer_key", &size);
 136         if (akey != NULL) {
 137                 free(akey);
 138                 secrets_delete("smb_traffic_analyzer_key");
 139                 printf("Removed installed key. Encryption deactivated.\n");
 140         } else {
 141         printf("No key is installed.\n");
 142         }
 143 }
 144
 145
 146 static void load_key_from_file_and_activate( char *filename)
 147 {
 148         char key[17] = {0};
 149         char *akey;
 150         size_t size;
 151         load_key_from_file(filename, key);
 152         printf("Loaded key from %s.\n",filename);
 153         akey = (char *) secrets_fetch("smb_traffic_analyzer_key", &size);
 154         if (akey != NULL) {
 155                 printf("Removing the old key.\n");
 156                 delete_key();
 157                 SAFE_FREE(akey);
 158         }
 159         printf("Installing the key from file %s\n",filename);
 160         secrets_store("smb_traffic_analyzer_key", key, strlen(key)+1);
 161 }
 162
 163 static void process_arguments(int argc, char **argv)
 164 {
 165         char co;
 166         while ((co = getopt(argc, argv, "hf:g:uc:s")) != EOF) {
 167                 switch(co) {
 168                 case 'h':
 169                         help();
 170                         exit(0);
 171                 case 's':
 172                         check_key();
 173                         break;
 174                 case 'g':
 175                         create_new_key_and_activate(optarg);
 176                         break;
 177                 case 'u':
 178                         delete_key();
 179                         break;
 180                 case 'c':
 181                         create_file_from_key(optarg);
 182                         break;
 183                 case 'f':
 184                         load_key_from_file_and_activate(optarg);
 185                         break;
 186                 default:
 187                         help();
 188                         break;
 189                 }
 190         }
 191 }
 192
 193 int main(int argc, char **argv)
 194 {
 195         sec_init();
 196         load_case_tables();
 197
 198         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
 199                 fprintf(stderr, "Can't load %s - run testparm to debug it\n",
 200                                                 get_dyn_CONFIGFILE());
 201         exit(1);
 202         }
 203
 204         if (argc == 1) {
 205                 help();
 206                 exit(1);
 207         }
 208
 209         process_arguments(argc, argv);
 210         exit(0);
 211 }