contrib/ntp/sntp/crypto.c

   1 /*
   2  * HMS: we need to test:
   3  * - OpenSSL versions, if we are building with them
   4  * - our versions
   5  *
   6  * We may need to test with(out) OPENSSL separately.
   7  */
   8
   9 #include <config.h>
  10 #include "crypto.h"
  11 #include <ctype.h>
  12 #include "isc/string.h"
  13 #include "ntp_md5.h"
  14
  15 #ifndef EVP_MAX_MD_SIZE
  16 # define EVP_MAX_MD_SIZE 32
  17 #endif
  18
  19 struct key *key_ptr;
  20 size_t key_cnt = 0;
  21
  22 typedef struct key Key_T;
  23
  24 static u_int
  25 compute_mac(
  26         u_char          digest[EVP_MAX_MD_SIZE],
  27         char const *    macname,
  28         void const *    pkt_data,
  29         u_int           pkt_size,
  30         void const *    key_data,
  31         u_int           key_size
  32         )
  33 {
  34         u_int           len  = 0;
  35 #if defined(OPENSSL) && defined(ENABLE_CMAC)
  36         size_t          slen = 0;
  37 #endif
  38         int             key_type;
  39
  40         INIT_SSL();
  41         key_type = keytype_from_text(macname, NULL);
  42
  43 #if defined(OPENSSL) && defined(ENABLE_CMAC)
  44         /* Check if CMAC key type specific code required */
  45         if (key_type == NID_cmac) {
  46                 CMAC_CTX *      ctx    = NULL;
  47                 u_char          keybuf[AES_128_KEY_SIZE];
  48
  49                 /* adjust key size (zero padded buffer) if necessary */
  50                 if (AES_128_KEY_SIZE > key_size) {
  51                         memcpy(keybuf, key_data, key_size);
  52                         memset((keybuf + key_size), 0,
  53                                (AES_128_KEY_SIZE - key_size));
  54                         key_data = keybuf;
  55                 }
  56
  57                 if (!(ctx = CMAC_CTX_new())) {
  58                         msyslog(LOG_ERR, "make_mac: CMAC %s CTX new failed.",   CMAC);
  59                 }
  60                 else if (!CMAC_Init(ctx, key_data, AES_128_KEY_SIZE,
  61                                     EVP_aes_128_cbc(), NULL)) {
  62                         msyslog(LOG_ERR, "make_mac: CMAC %s Init failed.",      CMAC);
  63                 }
  64                 else if (!CMAC_Update(ctx, pkt_data, (size_t)pkt_size)) {
  65                         msyslog(LOG_ERR, "make_mac: CMAC %s Update failed.",    CMAC);
  66                 }
  67                 else if (!CMAC_Final(ctx, digest, &slen)) {
  68                         msyslog(LOG_ERR, "make_mac: CMAC %s Final failed.",     CMAC);
  69                         slen = 0;
  70                 }
  71                 len = (u_int)slen;
  72
  73                 if (ctx)
  74                         CMAC_CTX_free(ctx);
  75                 /* Test our AES-128-CMAC implementation */
  76
  77         } else  /* MD5 MAC handling */
  78 #endif
  79         {
  80                 EVP_MD_CTX *    ctx;
  81
  82                 if (!(ctx = EVP_MD_CTX_new())) {
  83                         msyslog(LOG_ERR, "make_mac: MAC %s Digest CTX new failed.",
  84                                 macname);
  85                         goto mac_fail;
  86                 }
  87 #ifdef OPENSSL  /* OpenSSL 1 supports return codes 0 fail, 1 okay */
  88 #           ifdef EVP_MD_CTX_FLAG_NON_FIPS_ALLOW
  89                 EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
  90 #           endif
  91                 /* [Bug 3457] DON'T use plain EVP_DigestInit! It would
  92                  *  kill the flags! */
  93                 if (!EVP_DigestInit_ex(ctx, EVP_get_digestbynid(key_type), NULL)) {
  94                         msyslog(LOG_ERR, "make_mac: MAC %s Digest Init failed.",
  95                                 macname);
  96                         goto mac_fail;
  97                 }
  98                 if (!EVP_DigestUpdate(ctx, key_data, key_size)) {
  99                         msyslog(LOG_ERR, "make_mac: MAC %s Digest Update key failed.",
 100                                 macname);
 101                         goto mac_fail;
 102                 }
 103                 if (!EVP_DigestUpdate(ctx, pkt_data, pkt_size)) {
 104                         msyslog(LOG_ERR, "make_mac: MAC %s Digest Update data failed.",
 105                                 macname);
 106                         goto mac_fail;
 107                 }
 108                 if (!EVP_DigestFinal(ctx, digest, &len)) {
 109                         msyslog(LOG_ERR, "make_mac: MAC %s Digest Final failed.",
 110                                 macname);
 111                         len = 0;
 112                 }
 113 #else /* !OPENSSL */
 114                 EVP_DigestInit(ctx, EVP_get_digestbynid(key_type));
 115                 EVP_DigestUpdate(ctx, key_data, key_size);
 116                 EVP_DigestUpdate(ctx, pkt_data, pkt_size);
 117                 EVP_DigestFinal(ctx, digest, &len);
 118 #endif
 119           mac_fail:
 120                 EVP_MD_CTX_free(ctx);
 121         }
 122
 123         return len;
 124 }
 125
 126 int
 127 make_mac(
 128         const void *    pkt_data,
 129         int             pkt_size,
 130         int             mac_size,
 131         Key_T const *   cmp_key,
 132         void *          digest
 133         )
 134 {
 135         u_int           len;
 136         u_char          dbuf[EVP_MAX_MD_SIZE];
 137
 138         if (cmp_key->key_len > 64 || mac_size <= 0)
 139                 return 0;
 140         if (pkt_size % 4 != 0)
 141                 return 0;
 142
 143         len = compute_mac(dbuf, cmp_key->typen,
 144                           pkt_data, (u_int)pkt_size,
 145                           cmp_key->key_seq, (u_int)cmp_key->key_len);
 146
 147
 148         if (len) {
 149                 if (len > (u_int)mac_size)
 150                         len = (u_int)mac_size;
 151                 memcpy(digest, dbuf, len);
 152         }
 153         return (int)len;
 154 }
 155
 156
 157 /* Generates a md5 digest of the key specified in keyid concatenated with the
 158  * ntp packet (exluding the MAC) and compares this digest to the digest in
 159  * the packet's MAC. If they're equal this function returns 1 (packet is
 160  * authentic) or else 0 (not authentic).
 161  */
 162 int
 163 auth_md5(
 164         void const *    pkt_data,
 165         int             pkt_size,
 166         int             mac_size,
 167         Key_T const *   cmp_key
 168         )
 169 {
 170         u_int           len       = 0;
 171         u_char const *  pkt_ptr   = pkt_data;
 172         u_char          dbuf[EVP_MAX_MD_SIZE];
 173
 174         if (mac_size <= 0 || (size_t)mac_size > sizeof(dbuf))
 175                 return FALSE;
 176
 177         len = compute_mac(dbuf, cmp_key->typen,
 178                           pkt_ptr, (u_int)pkt_size,
 179                           cmp_key->key_seq, (u_int)cmp_key->key_len);
 180
 181         pkt_ptr += pkt_size + 4;
 182         if (len > (u_int)mac_size)
 183                 len = (u_int)mac_size;
 184
 185         /* isc_tsmemcmp will be better when its easy to link with.  sntp
 186          * is a 1-shot program, so snooping for timing attacks is
 187          * Harder.
 188          */
 189         return ((u_int)mac_size == len) && !memcmp(dbuf, pkt_ptr, len);
 190 }
 191
 192 static int
 193 hex_val(
 194         unsigned char x
 195         )
 196 {
 197         int val;
 198
 199         if ('0' <= x && x <= '9')
 200                 val = x - '0';
 201         else if ('a' <= x && x <= 'f')
 202                 val = x - 'a' + 0xa;
 203         else if ('A' <= x && x <= 'F')
 204                 val = x - 'A' + 0xA;
 205         else
 206                 val = -1;
 207
 208         return val;
 209 }
 210
 211 /* Load keys from the specified keyfile into the key structures.
 212  * Returns -1 if the reading failed, otherwise it returns the
 213  * number of keys it read
 214  */
 215 int
 216 auth_init(
 217         const char *keyfile,
 218         struct key **keys
 219         )
 220 {
 221         FILE *keyf = fopen(keyfile, "r");
 222         struct key *prev = NULL;
 223         int scan_cnt, line_cnt = 1;
 224         char kbuf[200];
 225         char keystring[129];
 226
 227         /* HMS: Is it OK to do this later, after we know we have a key file? */
 228         INIT_SSL();
 229
 230         if (keyf == NULL) {
 231                 if (debug)
 232                         printf("sntp auth_init: Couldn't open key file %s for reading!\n", keyfile);
 233                 return -1;
 234         }
 235         if (feof(keyf)) {
 236                 if (debug)
 237                         printf("sntp auth_init: Key file %s is empty!\n", keyfile);
 238                 fclose(keyf);
 239                 return -1;
 240         }
 241         key_cnt = 0;
 242         while (!feof(keyf)) {
 243                 char * octothorpe;
 244                 struct key *act;
 245                 int goodline = 0;
 246
 247                 if (NULL == fgets(kbuf, sizeof(kbuf), keyf))
 248                         continue;
 249
 250                 kbuf[sizeof(kbuf) - 1] = '\0';
 251                 octothorpe = strchr(kbuf, '#');
 252                 if (octothorpe)
 253                         *octothorpe = '\0';
 254                 act = emalloc(sizeof(*act));
 255                 /* keep width 15 = sizeof struct key.typen - 1 synced */
 256                 scan_cnt = sscanf(kbuf, "%d %15s %128s",
 257                                         &act->key_id, act->typen, keystring);
 258                 if (scan_cnt == 3) {
 259                         int len = strlen(keystring);
 260                         goodline = 1;   /* assume best for now */
 261                         if (len <= 20) {
 262                                 act->key_len = len;
 263                                 memcpy(act->key_seq, keystring, len + 1);
 264                         } else if ((len & 1) != 0) {
 265                                 goodline = 0; /* it's bad */
 266                         } else {
 267                                 int j;
 268                                 act->key_len = len >> 1;
 269                                 for (j = 0; j < len; j+=2) {
 270                                         int val;
 271                                         val = (hex_val(keystring[j]) << 4) |
 272                                                hex_val(keystring[j+1]);
 273                                         if (val < 0) {
 274                                                 goodline = 0; /* it's bad */
 275                                                 break;
 276                                         }
 277                                         act->key_seq[j>>1] = (char)val;
 278                                 }
 279                         }
 280                         act->typei = keytype_from_text(act->typen, NULL);
 281                         if (0 == act->typei) {
 282                                 printf("%s: line %d: key %d, %s not supported - ignoring\n",
 283                                         keyfile, line_cnt,
 284                                         act->key_id, act->typen);
 285                                 goodline = 0; /* it's bad */
 286                         }
 287                 }
 288                 if (goodline) {
 289                         act->next = NULL;
 290                         if (NULL == prev)
 291                                 *keys = act;
 292                         else
 293                                 prev->next = act;
 294                         prev = act;
 295                         key_cnt++;
 296                 } else {
 297                         if (debug) {
 298                                 printf("auth_init: scanf %d items, skipping line %d.",
 299                                         scan_cnt, line_cnt);
 300                         }
 301                         free(act);
 302                 }
 303                 line_cnt++;
 304         }
 305         fclose(keyf);
 306
 307         key_ptr = *keys;
 308         return key_cnt;
 309 }
 310
 311 /* Looks for the key with keyid key_id and sets the d_key pointer to the
 312  * address of the key. If no matching key is found the pointer is not touched.
 313  */
 314 void
 315 get_key(
 316         int key_id,
 317         struct key **d_key
 318         )
 319 {
 320         struct key *itr_key;
 321
 322         if (key_cnt == 0)
 323                 return;
 324         for (itr_key = key_ptr; itr_key; itr_key = itr_key->next) {
 325                 if (itr_key->key_id == key_id) {
 326                         *d_key = itr_key;
 327                         break;
 328                 }
 329         }
 330         return;
 331 }