А. Конан Доил. Пляшущие человечки

· Использование нестойких алгоритмов идентификации

К сожалению, взаимодействие объектов по виртуальному каналу в распре­деленной ВС не является панацеей от всех проблем, связанных с иденти­фикацией объектов РВС. ВК - необходимое, но не достаточное условие безопасного взаимодействия. Чрезвычайно важным в данном случае стано­вится выбор алгоритма идентификации при создании виртуального кана­ла. Основное требование, предъявляемое к этим алгоритмам, состоит в сле­дующем: перехват ключевой информации, которой обмениваются объекты РВС при создании ВК, не должен позволить атакующему получить итого­вые идентификаторы канала и объектов. Однако в базовых алгоритмах идентифика­ции, используемых при создании ВК в большинстве существующих сетевых ОС, это требование практически не учитывается.

 

· Отсутствие контроля за виртуальными каналами связи

Объекты распределенной ВС, взаимодействующие по виртуальным кана­лам, могут подвергаться типовой атаке «отказ в обслуживании». Особен­ность этого воздействия состоит в том, что, действуя абсолютно легальны­ми средствами системы, можно удаленно добиться нарушения ее работоспособности. В чем причина успеха данной атаки? В отсутствии необхо­димого контроля над соединением. При этом задача контроля распадается на две подзадачи:

• контроль за созданием соединения;

• контроль за использованием соединения.

 Если пути решения второй задачи понятны - обычно соединение раз­рывается по тайм-ауту, определенному системой, - так сделано во всех из­вестных сетевых ОС (однако тут возникает серьезная проблема выбора конкретного значения тайм-аута), то контроль за созданием ВК достаточ­но сложен: в системе, где отсутствует статическая ключевая информация обо всех ее объектах, невозможно отделить ложные запросы на создание соединения от настоящих. Очевидно также, что если один субъект сетево­го взаимодействия будет иметь возможность анонимно занимать неогра­ниченное число каналов связи с удаленным объектом, то подобная систе­ма может быть полностью парализована данным субъектом. Таким образом, если лю­бой объект в распределенной системе способен анонимно послать сооб­щение от имени другого объекта (например, в Internet маршрутизаторы не проверяют IP-адрес отправителя), то в подобной распределенной ВС практически невозможен контроль за созданием виртуальных соедине­ний. Поэтому основная причина типовой угрозы «отказ в обслужива­нии» - это отсутствие приемлемого решения задачи контроля за маршру­том сообщений.

 

· Отсутствие возможности контролировать маршрут сообщений

Если в РВС не предусмотреть контроля за маршрутом сооб­щения, то адрес отправителя сообщения оказывается ничем не подтверж­денным. Таким образом, в системе будет существовать возможность ра­боты от имени любого объекта путем указания в заголовке сообщения чужого адреса отправителя (IP Spoofing). В подобной РВС затруднитель­но определить, откуда на самом деле пришло сообщение, а следовательно - вычислить координаты атакующего (в Internet невозможно найти ини­циатора однонаправленной удаленной атаки).

 

· Отсутствие полной информации об объектах РВС

В распределенной системе с разветвленной структурой, состоящей из большого числа объектов, может возникнуть ситуация, когда для доступа к определенному хосту у субъекта взаимодействия не окажется необходимой информации, то есть адреса данного объекта. Очевидно, что в системе подобного типа существует потенциальная опасность внесения ложного объекта и выдачи одного объекта за другой путем передачи ложного ответа на поисковый запрос.

 

· Отсутствие криптозащиты сообщений

В распределенных ВС связь между объектами системы осуществляется по виртуальным каналам связи, а следовательно, хакер имеет принципиальную возможность прослушать канал, получив несанкционированный доступ к информации, которой обмениваются по сети се абоненты. Если эта информация не зашифрована, то возникает угроза атаки типа «анализ сетевого трафика».

 

· Отсутствие выделенного канала связи между объектами сети Internet

Глобальная сеть не может быть построена по принципу прямой связи между объектами, поскольку для каждого объекта невозможно обеспечить вы деленный канал связи с любым другим объектом. Поэтому в Internet связь осуществляется через цепочку маршрутизаторов, а следовательно, сообщение, проходя через большое количество промежуточных подсетей, может быть перехвачено. Также к Internet подключено большое число локальных Ethernet-сетей, использующих топологию «общая шина»; в сетях с такой

топологией несложно программно осуществлять перехват сообщений.

· Недостаточные идентификация и аутентификация

В базовых протоколах обмена идентификация и аутентификация объек­тов практически отсутствуют. Так, например, в прикладных протоколах . FTP, TELNET, РОРЗ имена и пароли пользователей передаются по сети в виде открытых незашифрованных сообщений.

 

· Использование нестойких алгоритмов идентификации объектов при создании виртуального TCP-соединения

Как уже подчеркивалось, протокол TCP является единственным базовым протоколом транспортного уровня, в функции которого заложена защита соединения. Однако использование простейшего алгоритма идентифика­ции объектов при создании виртуального TCP-канала, особен­но при условии применения в сетевых ОС простейших времязависимых законов генерации TCP-идентификаторов (ISN), сводит на нет все попыт­ки обеспечения идентификации канала и объектов при их взаимодействии по протоколу TCP.

 

· Отсутствие криптозащиты сообщений

В существующих базовых протоколах семейства TCP/IP, обеспечиваю­щих взаимодействие на сетевом и транспортном уровнях, не предусмотре­на возможность шифрования сообщений, хотя очевидно, что добавить ее в протокол TCP не составляло труда. Разработчики решили переложить задачу криптозащиты на протоколы более высоких уровней, например прикладного уровня. При этом базовые протоколы прикладного уровня (FTP, TELNET, HTTP и др.) также не предусматривали никакого шифро­вания сообщений. Только не так давно появился общедоступный приклад­ной протокол SSL, встроенный в Netscape Navigator, позволяющий как на­дежно зашифровать сообщение, так и подтвердить его подлинность. В заключение хотелось бы заметить, что все описанные выше причины, по которым возможна успешная реализация угроз безопасности РВС, делают сеть Internet небезопасной. А следовательно, все пользователи сети могут быть атакованы в любой момент.

 

Подведем итоги.

Учитывая все вышесказанное, я думаю, что студентам кафедры АСОИУ уже сейчас не представляется никакой сложности для несанкционированного доступа к терминалам серверов с правами администраторов (причем это не необоснованное высказывание). Другой вопрос – целесообразности всего этого. Я думаю что не стоит проверять все вышесказанное на практике в целях своей же безопасности.

В целом, вычислительная сеть университета администрируется весьма неплохо, нужно отдать должное системным администраторам. На серверах стоят последние версии операционных систем. Однако на chuck.stu.lipetsk.ru почему-то у обычных пользователей нет прав на компилирование Си программ. Почему? Может это и есть слабое звено в администрировании, или это еще одна предосторожность администратора? Хотя на tomcat.am.lstu обычным смертным разрешено…

Вообще-то взлом octopus.stu.lipetsk.ru был бы неуважением своей же кафедры. Ведь та защита которая там присутствует направлена не для того, чтобы предотвратить проникновение злоумышленника, а для элементарной защиты от неопытных пользователей. 

 

ПРИЛОЖЕНИЕ.

В целях безопасности, приводим только фрагменты программы. Файл john.c

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <sys/stat.h>

 

#include "arch.h"

#include "misc.h"

#include "params.h"

#include "path.h"

#include "memory.h"

#include "list.h"

#include "tty.h"

#include "signals.h"

#include "idle.h"

#include "common.h"

#include "formats.h"

#include "loader.h"

#include "logger.h"

#include "status.h"

#include "options.h"

#include "config.h"

#include "bench.h"

#include "charset.h"

#include "single.h"

#include "wordlist.h"

#include "inc.h"

#include "external.h"

#include "batch.h"

 

#if CPU_DETECT

extern int CPU_detect();

#endif

 

extern struct fmt_main fmt_DES, fmt_BSDI, fmt_MD5, fmt_BF;

extern struct fmt_main fmt_AFS, fmt_LM;

 

extern int unshadow(int argc, char **argv);

extern int unafs(int argc, char **argv);

extern int unique(int argc, char **argv);

 

static struct db_main database;

static struct fmt_main dummy_format;

 

static void john_register_one(struct fmt_main *format)

{

       if (options.format)

       if (strcmp(options.format, format->params.label)) return;

 

       fmt_register(format);

}

 

static void john_register_all()

{

       if (options.format) strlwr(options.format);

 

       john_register_one(&fmt_DES);

       john_register_one(&fmt_BSDI);

       john_register_one(&fmt_MD5);

       john_register_one(&fmt_BF);

       john_register_one(&fmt_AFS);

       john_register_one(&fmt_LM);

 

       if (!fmt_list) {

                   fprintf(stderr, "Unknown ciphertext format name requested\n");

                   error();

       }

}

 

static void john_load()

{

       struct list_entry *current;

 

       umask(077);

 

       if (options.flags & FLG_EXTERNAL_CHK)

                   ext_init(options.external);

 

       if (options.flags & FLG_MAKECHARS_CHK) {

                   options.loader.flags |= DB_CRACKED;

                   ldr_init_database(&database, &options.loader);

 

                   if (options.flags & FLG_PASSWD) {

                              ldr_show_pot_file(&database, LOG_NAME);

 

                              database.options->flags |= DB_PLAINTEXTS;

                              if ((current = options.passwd->head))

                              do {

                                          ldr_show_pw_file(&database, current->data);

                              } while ((current = current->next));

                   } else {

                              database.options->flags |= DB_PLAINTEXTS;

                              ldr_show_pot_file(&database, LOG_NAME);

                   }

 

                   return;

       }

 

       if (options.flags & FLG_STDOUT) {

                   ldr_init_database(&database, &options.loader);

                   database.format = &dummy_format;

                   memset(&dummy_format, 0, sizeof(dummy_format));

                   dummy_format.params.plaintext_length = options.length;

                   dummy_format.params.flags = FMT_CASE | FMT_8_BIT;

       }

 

       if (options.flags & FLG_PASSWD) {

                   if (options.flags & FLG_SHOW_CHK) {

                              options.loader.flags |= DB_CRACKED;

                              ldr_init_database(&database, &options.loader);

 

                              ldr_show_pot_file(&database, LOG_NAME);

 

                              if ((current = options.passwd->head))

                              do {

                                          ldr_show_pw_file(&database, current->data);

                              } while ((current = current->next));

 

                              printf("%s%d password%s cracked, %d left\n",

                                          database.guess_count ? "\n" : "",

                                          database.guess_count,

                                          database.guess_count != 1 ? "s" : "",

                                          database.password_count -

                                          database.guess_count);

 

                              return;

                   }

 

                   if (options.flags & (FLG_SINGLE_CHK | FLG_BATCH_CHK))

                              options.loader.flags |= DB_WORDS;

                   else

                   if (mem_saving_level)

                              options.loader.flags &= ~DB_LOGIN;

                   ldr_init_database(&database, &options.loader);

 

                   if ((current = options.passwd->head))

                   do {

                              ldr_load_pw_file(&database, current->data);

                   } while ((current = current->next));

 

                   ldr_load_pot_file(&database, LOG_NAME);

 

                   ldr_fix_database(&database);

 

                   printf("Loaded %d password%s%s",

                              database.password_count,

                              database.password_count != 1 ? "s" : "",

                              database.password_count ? "" : ", exiting...");

                   if (database.password_count > 1) {

                              printf(" with ");

                              printf(database.salt_count != 1 ? "%d" : "no",

                                          database.salt_count);

                              printf(" different salts");

                   }

                   if (database.password_count)

                              printf(" (%s [%s])\n",

                                          database.format->params.format_name,

                                          database.format->params.algorithm_name);

                   else

                              putchar('\n');

 

                   if ((options.flags & FLG_PWD_REQ) && !database.salts) exit(0);

       }

}

 

static void john_init(int argc, char **argv)

{

#if CPU_DETECT

       if (!CPU_detect()) {

#if CPU_REQ

                   fprintf(stderr, "Sorry, %s is required\n", CPU_NAME);

                   error();

#endif

       }

#endif

 

       path_init(argv);

       cfg_init(CFG_NAME);

       status_init(NULL, 1);

       opt_init(argc, argv);

 

       john_register_all();

       common_init();

 

       sig_init(idle_yield);

 

       john_load();

}

 

static void john_run()

{

       if (options.flags & FLG_TEST_CHK)

                   benchmark_all();

       else

       if (options.flags & FLG_MAKECHARS_CHK)

                   do_makechars(&database, options.charset);

       else

       if (options.flags & FLG_CRACKING_CHK) {

                   if (!(options.flags & FLG_STDOUT)) log_init(LOG_NAME);

                   tty_init();

 

                   if (options.flags & FLG_SINGLE_CHK)

                              do_single_crack(&database);

                   else

                   if (options.flags & FLG_WORDLIST_CHK)

                              do_wordlist_crack(&database, options.wordlist,

                                          (options.flags & FLG_RULES) != 0);

                   else

                   if (options.flags & FLG_INC_CHK)

                              do_incremental_crack(&database, options.charset);

                   else

                   if (options.flags & FLG_EXTERNAL_CHK)

                              do_external_crack(&database);

                   else

                   if (options.flags & FLG_BATCH_CHK)

                              do_batch_crack(&database);

 

                   status_print();

                   tty_done();

                   if (!(options.flags & FLG_STDOUT)) log_done();

       }

}

 

static void john_done()

{

       path_done();

 

       check_abort();

}

 

int main(int argc, char **argv)

{

       char *name;

 

#ifdef __DJGPP__

       if (--argc <= 0) return 1;

       if ((name = strrchr(argv[0], '/')))

                   strcpy(name + 1, argv[1]);

       name = argv[1];

       argv[1] = argv[0];

       argv++;

#else

       if (!argv[0])

                   name = "";

       else

       if ((name = strrchr(argv[0], '/')))

                   name++;

       else

                   name = argv[0];

#endif

 

#ifdef __CYGWIN32__

       if (strlen(name) > 4)

       if (!strcmp(strlwr(name) + strlen(name) - 4, ".exe"))

                   name[strlen(name) - 4] = 0;

#endif

 

       if (!strcmp(name, "john")) {

                   john_init(argc, argv);

                   john_run();

                   john_done();

 

                   return 0;

       }

 

       if (!strcmp(name, "unshadow"))

                   return unshadow(argc, argv);

 

       if (!strcmp(name, "unafs"))

                   return unafs(argc, argv);

 

       if (!strcmp(name, "unique"))

                   return unique(argc, argv);

 

       fprintf(stderr, "Sorry, I can't find myself\n");

       return 1;

}

Файл des_bs.c

#include <string.h>

 

#include "arch.h"

#include "DES_std.h"

#include "DES_bs.h"

 

DES_bs_combined DES_bs_all;

int DES_bs_mem_saving = 0;

 

extern void DES_bs_body();

 

void DES_bs_init()

{

       int index, bit;

 

       for (index = 0; index < 0x300; index++) {

                   bit = DES_K_bits[index];

                   bit -= bit >> 3;

                   DES_bs_all.Kp[index] = &DES_bs_all.K[55 - bit];

       }

}

 

void DES_bs_set_salt(ARCH_WORD salt)

{

       register int src, dst;

       register ARCH_WORD mask;

 

       mask = 1;

       for (dst = 0; dst < 48; dst++) {

                   if (dst == 24) mask = 1;

 

                   if (salt & mask) {

                              if (dst < 24) src = dst + 24; else src = dst - 24;

                   } else src = dst;

 

                   DES_bs_all.E[dst] = &DES_bs_all.B[DES_E[src]];

                   DES_bs_all.E[dst + 48] = &DES_bs_all.B[DES_E[src] + 32];

 

                   mask <<= 1;

       }

}

 

void DES_bs_clear_keys()

{

       memset(DES_bs_all.K, 0, sizeof(DES_bs_all.K));

}

 

void DES_bs_set_key(char *key, int index)

{

       register char *ptr;

       register int ofs, bit;

       register ARCH_WORD value;

 

       ofs = 56;

       for (ptr = key; *ptr && ofs; ptr++) {

                   bit = (ofs -= 7);

                   value = *ptr & 0x7F;

 

                   do {

                              DES_bs_all.K[bit++] |= (value & 1) << index;

                   } while (value >>= 1);

       }

}

 

void DES_bs_crypt(int count)

{

       register int bit;

       register ARCH_WORD R, L;

 

       memset(DES_bs_all.B, 0, sizeof(DES_bs_all.B));

 

       do {

                   DES_bs_body();

 

                   if (!--count) break;

 

                   for (bit = 0; bit < 32; bit++) {

                              R = DES_bs_all.B[bit];

                              L = DES_bs_all.B[bit + 32];

                              DES_bs_all.B[bit + 32] = R;

                              DES_bs_all.B[bit] = L;

                   }

       } while (1);

}

 

ARCH_WORD *DES_bs_get_binary(char *ciphertext)

{

       static ARCH_WORD out[64];

       ARCH_WORD *raw;

       int bit;

       int index, shift;

       int value;

 

       raw = DES_raw_get_binary(ciphertext);

 

       out[1] = out[0] = 0;

       for (bit = 0; bit < 64; bit++) {

                   index = bit >> 4;

 

/* Swap L and R here instead of doing it one more time in DES_bs_crypt() */

                   index ^= 2;

 

/* Calculate the number of one of the 16 data bits in raw[index] */

                   shift = ((bit & 0xC) << 1) + (bit & 3) + 1;

 

/* Get the bit */

                   value = (raw[index] >> shift) & 1;

 

                   if (DES_bs_mem_saving)

/* Memory saving: pack the bits into two words */

                              out[bit >> 5] |= value << (bit & 0x1F);

                   else

/* We either set or clear all the bits in every word */

                              out[bit] = value ? ~(ARCH_WORD)0 : 0;

       }

 

       return out;

}

 

int DES_bs_binary_hash(ARCH_WORD *binary, int count)

{

       int bit, result;

 

       if (DES_bs_mem_saving)

                   return (int)*binary & ((1 << count) - 1);

 

       result = 0;

       for (bit = 0; bit < count; bit++)

                   if (binary[bit]) result |= 1 << bit;

 

       return result;

}

 

int DES_bs_get_hash(int index, int count)

{

       register int bit, result;

       register ARCH_WORD mask;

 

       mask = (ARCH_WORD)1 << index;

       result = 0;

       for (bit = 0; bit < count; bit++)

                   if (DES_bs_all.B[bit] & mask) result |= 1 << bit;

 

       return result;

}

 

/*

 * The trick I used here allows to compare one ciphertext against all the

 * DES_bs_crypt() outputs in just O(log2(ARCH_BITS)) operations.

 */

int DES_bs_cmp_all(ARCH_WORD *binary, int count)

{

       register int bit;

       register ARCH_WORD mask;

 

       mask = 0;

       if (DES_bs_mem_saving)

       for (bit = 0; bit < ((count < 32) ? count : 32); bit++) {

                   mask |= DES_bs_all.B[bit] ^

                              ((binary[0] & (1 << bit)) ? ~(ARCH_WORD)0 : 0);

                   if (mask == ~(ARCH_WORD)0) return 0;

       }

       else

       for (bit = 0; bit < count; bit++) {

                   mask |= DES_bs_all.B[bit] ^ binary[bit];

                   if (mask == ~(ARCH_WORD)0) return 0;

       }

 

       return 1;

}

 

int DES_bs_cmp_one(ARCH_WORD *binary, int count, int index)

{

       register int bit;

       register ARCH_WORD mask;

 

       if (DES_bs_mem_saving) {

                   for (bit = 0; bit < count; bit++)

                   if (((DES_bs_all.B[bit] >> index) ^

                              (binary[bit >> 5] >> (bit & 0x1F))) & 1) return 0;

 

                   return 1;

       }

 

       mask = (ARCH_WORD)1 << index;

       for (bit = 0; bit < count; bit++)

                   if ((DES_bs_all.B[bit] ^ binary[bit]) & mask) return 0;

 

       return 1;

}