deattack.c

   1 /*
   2  * Cryptographic attack detector for ssh - source code
   3  *
   4  * Copyright (c) 1998 CORE SDI S.A., Buenos Aires, Argentina.
   5  *
   6  * All rights reserved. Redistribution and use in source and binary
   7  * forms, with or without modification, are permitted provided that
   8  * this copyright notice is retained.
   9  *
  10  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  11  * WARRANTIES ARE DISCLAIMED. IN NO EVENT SHALL CORE SDI S.A. BE
  12  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY OR
  13  * CONSEQUENTIAL DAMAGES RESULTING FROM THE USE OR MISUSE OF THIS
  14  * SOFTWARE.
  15  *
  16  * Ariel Futoransky <futo@core-sdi.com>
  17  * <http://www.core-sdi.com>
  18  */
  19
  20 #include "includes.h"
  21
  22 #include "deattack.h"
  23 #include "log.h"
  24 #include "crc32.h"
  25 #include "getput.h"
  26 #include "xmalloc.h"
  27
  28 /* SSH Constants */
  29 #define SSH_MAXBLOCKS   (32 * 1024)
  30 #define SSH_BLOCKSIZE   (8)
  31
  32 /* Hashing constants */
  33 #define HASH_MINSIZE    (8 * 1024)
  34 #define HASH_ENTRYSIZE  (2)
  35 #define HASH_FACTOR(x)  ((x)*3/2)
  36 #define HASH_UNUSEDCHAR (0xff)
  37 #define HASH_UNUSED     (0xffff)
  38 #define HASH_IV         (0xfffe)
  39
  40 #define HASH_MINBLOCKS  (7*SSH_BLOCKSIZE)
  41
  42
  43 /* Hash function (Input keys are cipher results) */
  44 #define HASH(x)         GET_32BIT(x)
  45
  46 #define CMP(a, b)       (memcmp(a, b, SSH_BLOCKSIZE))
  47
  48 static void
  49 crc_update(u_int32_t *a, u_int32_t b)
  50 {
  51         b ^= *a;
  52         *a = ssh_crc32((u_char *)&b, sizeof(b));
  53 }
  54
  55 /* detect if a block is used in a particular pattern */
  56 static int
  57 check_crc(u_char *S, u_char *buf, u_int32_t len)
  58 {
  59         u_int32_t crc;
  60         u_char *c;
  61
  62         crc = 0;
  63         for (c = buf; c < buf + len; c += SSH_BLOCKSIZE) {
  64                 if (!CMP(S, c)) {
  65                         crc_update(&crc, 1);
  66                         crc_update(&crc, 0);
  67                 } else {
  68                         crc_update(&crc, 0);
  69                         crc_update(&crc, 0);
  70                 }
  71         }
  72         return (crc == 0);
  73 }
  74
  75
  76 /* Detect a crc32 compensation attack on a packet */
  77 int
  78 detect_attack(u_char *buf, u_int32_t len)
  79 {
  80         static u_int16_t *h = (u_int16_t *) NULL;
  81         static u_int32_t n = HASH_MINSIZE / HASH_ENTRYSIZE;
  82         u_int32_t i, j;
  83         u_int32_t l;
  84         u_char *c;
  85         u_char *d;
  86
  87         if (len > (SSH_MAXBLOCKS * SSH_BLOCKSIZE) ||
  88             len % SSH_BLOCKSIZE != 0) {
  89                 fatal("detect_attack: bad length %d", len);
  90         }
  91         for (l = n; l < HASH_FACTOR(len / SSH_BLOCKSIZE); l = l << 2)
  92                 ;
  93
  94         if (h == NULL) {
  95                 debug("Installing crc compensation attack detector.");
  96                 h = (u_int16_t *) xmalloc(l * HASH_ENTRYSIZE);
  97                 n = l;
  98         } else {
  99                 if (l > n) {
 100                         h = (u_int16_t *) xrealloc(h, l * HASH_ENTRYSIZE);
 101                         n = l;
 102                 }
 103         }
 104
 105         if (len <= HASH_MINBLOCKS) {
 106                 for (c = buf; c < buf + len; c += SSH_BLOCKSIZE) {
 107                         for (d = buf; d < c; d += SSH_BLOCKSIZE) {
 108                                 if (!CMP(c, d)) {
 109                                         if ((check_crc(c, buf, len)))
 110                                                 return (DEATTACK_DETECTED);
 111                                         else
 112                                                 break;
 113                                 }
 114                         }
 115                 }
 116                 return (DEATTACK_OK);
 117         }
 118         memset(h, HASH_UNUSEDCHAR, n * HASH_ENTRYSIZE);
 119
 120         for (c = buf, j = 0; c < (buf + len); c += SSH_BLOCKSIZE, j++) {
 121                 for (i = HASH(c) & (n - 1); h[i] != HASH_UNUSED;
 122                     i = (i + 1) & (n - 1)) {
 123                         if (!CMP(c, buf + h[i] * SSH_BLOCKSIZE)) {
 124                                 if (check_crc(c, buf, len))
 125                                         return (DEATTACK_DETECTED);
 126                                 else
 127                                         break;
 128                         }
 129                 }
 130                 h[i] = j;
 131         }
 132         return (DEATTACK_OK);
 133 }