HOWTO xác định xem mã có đang chạy trong ngữ cảnh trình xử lý tín hiệu không?

Question

Tôi vừa phát hiện ra rằng ai đó đang gọi điện thoại - từ một trình xử lý tín hiệu - một chức năng an toàn không chắc chắn-an toàn mà tôi đã viết. Và, tất nhiên, tôi nhận được sự đổ lỗi (mặc dù cảnh báo trong tài liệu của tôi). (Cùng một lập trình viên đang gọi tất cả các chức năng không an toàn-tín hiệu-an toàn từ bộ xử lý tín hiệu của mình.)

Vì vậy, bây giờ tôi tò mò: làm thế nào để tránh tình trạng này xảy ra lần nữa? Tôi muốn có thể dễ dàng xác định xem mã của tôi có đang chạy trong ngữ cảnh xử lý tín hiệu (ngôn ngữ là C, nhưng không phải giải pháp áp dụng cho bất kỳ ngôn ngữ nào không?):

int myfunc(void) { 
    if(in_signal_handler_context()) { return(-1) } 
    // rest of function goes here 
    return(0); 
} 

Đây là dưới Linux. Hy vọng đây không phải là câu trả lời dễ dàng, nếu không tôi sẽ cảm thấy như một thằng ngốc.

Answer 1

Dường như, Linux/x86 mới hơn (có lẽ kể từ hạt nhân 2.6.x) gọi trình xử lý tín hiệu từ số vdso. Bạn có thể sử dụng thực tế này để gây ra sự tấn công khủng khiếp sau khi thế giới không ngờ:

#include <stdio.h> 
#include <stdlib.h> 
#include <stdint.h> 
#include <string.h> 
#include <signal.h> 

#include <unistd.h> 

uintmax_t vdso_start = 0; 
uintmax_t vdso_end = 0;    /* actually, next byte */ 

int check_stack_for_vdso(uint32_t *esp, size_t len) 
{ 
    size_t i; 

    for (i = 0; i < len; i++, esp++) 
      if (*esp >= vdso_start && *esp < vdso_end) 
        return 1; 

    return 0; 
} 

void handler(int signo) 
{ 
    uint32_t *esp; 

    __asm__ __volatile__ ("mov %%esp, %0" : "=r"(esp)); 
    /* XXX only for demonstration, don't call printf from a signal handler */ 
    printf("handler: check_stack_for_vdso() = %d\n", check_stack_for_vdso(esp, 20)); 
} 

void parse_maps() 
{ 
    FILE *maps; 
    char buf[256]; 
    char path[7]; 
    uintmax_t start, end, offset, inode; 
    char r, w, x, p; 
    unsigned major, minor; 

    maps = fopen("/proc/self/maps", "rt"); 
    if (maps == NULL) 
      return; 

    while (!feof(maps) && !ferror(maps)) { 
      if (fgets(buf, 256, maps) != NULL) { 
        if (sscanf(buf, "%jx-%jx %c%c%c%c %jx %u:%u %ju %6s", 
            &start, &end, &r, &w, &x, &p, &offset, 
            &major, &minor, &inode, path) == 11) { 
          if (!strcmp(path, "[vdso]")) { 
            vdso_start = start; 
            vdso_end = end; 
            break; 
          } 
        } 
      } 
    } 

    fclose(maps); 

    printf("[vdso] at %jx-%jx\n", vdso_start, vdso_end); 
} 

int main() 
{ 
    struct sigaction sa; 
    uint32_t *esp; 

    parse_maps(); 
    memset(&sa, 0, sizeof(struct sigaction)); 
    sa.sa_handler = handler; 
    sa.sa_flags = SA_RESTART; 

    if (sigaction(SIGUSR1, &sa, NULL) < 0) { 
      perror("sigaction"); 
      exit(1); 
    } 

    __asm__ __volatile__ ("mov %%esp, %0" : "=r"(esp)); 
    printf("before kill: check_stack_for_vdso() = %d\n", check_stack_for_vdso(esp, 20)); 

    kill(getpid(), SIGUSR1); 

    __asm__ __volatile__ ("mov %%esp, %0" : "=r"(esp)); 
    printf("after kill: check_stack_for_vdso() = %d\n", check_stack_for_vdso(esp, 20)); 

    return 0; 
} 

SCNR.

Answer 2

Có hai cách thích hợp để đối phó với điều này:

• Có đồng nghiệp của bạn ngừng làm điều sai trái. Tuy nhiên, may mắn sẽ kéo cái này ra với ông chủ ...

• Làm cho hàm của bạn trở lại và không an toàn. Nếu cần, hãy cung cấp chức năng có chữ ký khác (ví dụ: sử dụng quy ước đặt tên *_r được sử dụng rộng rãi) với các đối số bổ sung cần thiết để bảo tồn trạng thái.

Đối với không đúng cách để làm điều này, trên Linux với GNU libc bạn có thể sử dụng backtrace() và bạn bè để đi qua danh sách người gọi của chức năng của bạn. Đó là không dễ dàng để có được quyền, an toàn hoặc di động, nhưng nó có thể làm cho một khoảng thời gian:

/* 
* *** Warning *** 
* 
* Black, fragile and unportable magic ahead 
* 
* Do not use this, lest the daemons of hell be unleashed upon you 
*/ 
int in_signal_handler_context() { 
     int i, n; 
     void *bt[1000]; 
     char **bts = NULL; 

     n = backtrace(bt, 1000); 
     bts = backtrace_symbols(bt, n); 

     for (i = 0; i < n; ++i) 
       printf("%i - %s\n", i, bts[i]); 

     /* Have a look at the caller chain */ 
     for (i = 0; i < n; ++i) { 
       /* Far more checks are needed here to avoid misfires */ 
       if (strstr(bts[i], "(__libc_start_main+") != NULL) 
         return 0; 
       if (strstr(bts[i], "libc.so.6(+") != NULL) 
         return 1; 
     } 

     return 0; 
} 


void unsafe() { 
     if (in_signal_handler_context()) 
       printf("John, you know you are an idiot, right?\n"); 
} 

Theo ý kiến ​​của tôi, nó chỉ có thể là tốt hơn để bỏ hơn là bị buộc phải viết mã như này.

Answer 3

Bạn có thể tìm ra thứ gì đó bằng cách sử dụng sigaltstack. Thiết lập một ngăn xếp tín hiệu thay thế, lấy con trỏ ngăn xếp theo một số cách an toàn không đồng bộ, nếu trong ngăn xếp thay thế tiếp tục, nếu không hủy bỏ().

Answer 4

Tôi đoán bạn cần làm như sau. Đây là một giải pháp phức tạp, kết hợp các thực hành tốt nhất không chỉ từ mã hóa, mà còn từ kỹ thuật phần mềm!

1. thuyết phục ông chủ rằng quy ước đặt tên trên trình xử lý tín hiệu là điều tốt. Đề xuất, ví dụ: Hungarian notation và nói rằng nó đã được sử dụng trong Microsoft với thành công lớn. Vì vậy, tất cả trình xử lý tín hiệu sẽ bắt đầu bằng sighnd, như sighndInterrupt.
2. Chức năng của bạn để phát hiện tín hiệu bối cảnh xử lý sẽ làm như sau:
   1. Lấy backtrace().
   2. Hãy xem có bất kỳ chức năng nào trong số đó bắt đầu bằng sighnd... hay không. Nếu có, xin chúc mừng, bạn đang ở trong một bộ xử lý tín hiệu!
   3. Nếu không, bạn thì không.
3. Cố gắng tránh làm việc với Jimmy trong cùng một công ty. "Có thể chỉ có một", bạn biết đấy.

Answer 5

cho mã tối ưu hóa tại -O2 hoặc tốt hơn (báo cáo ISTR) đã tìm thấy cần phải thêm -fno-omit-frame-pointer

khác gcc sẽ tối ưu hóa các thông tin ngăn xếp bối cảnh

Answer 6

Nếu chúng ta có thể giả định của bạn ứng dụng không chặn tín hiệu theo cách thủ công bằng cách sử dụng sigprocmask() hoặc pthread_sigmask(), sau đó điều này khá đơn giản: nhận ID luồng hiện tại của bạn (tid). Mở /proc/tid/status và nhận các giá trị cho SigBlk và SigCgt. AND hai giá trị đó. Nếu kết quả của số đó AND khác không, thì luồng đó hiện đang chạy từ bên trong trình xử lý tín hiệu. Tôi đã tự mình thử nghiệm và nó hoạt động.