Account 로그인

Red Hat Product Security was made aware of a vulnerability affecting the Linux kernel's implementation of the Bluetooth L2CAP protocol.  The vulnerability was named BlueBorne and was assigned an ID - CVE-2017-1000251.

A vulnerable system would need to have Bluetooth (hardware + service) enabled and an attacking device would need to be within 

its operating range.

Bluetooth is a short-range wireless communication technology meant to connect devices over radio channels without need for a physical connection. The radio channel forms a physical layer in the Bluetooth stack, analogous to cables in other networks. Above this physical channel, the Bluetooth stack hosts different logical channels and their associated protocols, such as Link Manager Protocol (LMP), Logical Link Control and Adaptation Protocol (L2CAP) and others. These protocols help with controlling the operation of devices in the Bluetooth network and provide services such as segmentation/reassembly of application data, error detection, retransmission and multiplexing of channels over a shared link.

A typical Bluetooth operation includes device discovery, connection establishment and configuration followed by data transmission. A radio channel provides a physical link between two devices. The L2CAP (Logical link control and adaptation protocol) channel provides a logical connection between two devices which could serve a single application. Multiple such logical connections share a physical link between two devices.

Kernel buffer overflow

Once a physical connection is established, L2CAP configures a logical link between two end-points to be used by an application. It is during this configuration of a channel that the stack buffer overflow issue can occur. L2CAP implementation in the Linux kernel stores these configuration parameters in a stack buffer object:

    if (test_bit(CONF_LOC_CONF_PEND, &chan->conf_state)) {
        char buf[64];  <= Kernel stack buffer stores L2CAP parameters

        len = l2cap_parse_conf_rsp(chan, rsp->data, len, buf, &result);
A Bluetooth client sends configuration parameters to a host, these are temporarily stored in the “buf” array above.

A malicious client can send L2CAP configuration packets with configuration parameters set to exceed 64 byte length of the “buf” array passed to the l2cap_parse_conf_rsp() routine. When these parameters are copied to the "buf" array, adjacent kernel stack memory is overwritten with their content. This exchange occurs prior to any authentication, while establishing a Bluetooth connection. As a result, an unauthenticated user who is able to connect to a system via Bluetooth, can use this flaw to overwrite kernel stack memory with malicious data.

System guards

Kernel stack memory corruption can be easily leveraged to execute arbitrary code with kernel ring 0 (above root) privileges on a system. Red Hat Enterprise Linux kernels are hardened with gcc(1) compile time options which protect against such memory corruption. On supported architectures the gcc(1) -fstack-protector option adds a canary value at the beginning of a function and before the function return address. The -fstack-protector-strong extends this canary protection around local stack variables including arrays of any type and length. As can be seen below,

BlueBorne - CVE-2017-1000251

After copying data to these stack variables, kernel validates the stack canary value stored in the stack frame to detect any memory corruption and aborts the impending attack by resorting to a kernel panic.

void __stack_chk_fail(void)
    panic("stack-protector: Kernel stack is corrupted in: %p\n",

The stack protection thus helps to prevent the arbitrary code execution with the kernel/root privileges.  Ie. on cpu architectures with support for this feature, this vulnerability is reduced to a denial of service, rather than a remote code execution one.


Red Hat Enterprise Linux kernels have received updates to address this buffer overflow.  The kernel functions 'L2cap_parse_conf_rsp' and 'l2cap_add_conf_opt' have been augmented to accept a new parameter specifying the length of the "buf" array. These functions then use the length parameter to contain the data copied from an incoming packet within "buf" limits, so as to prevent the stack buffer overflow.



Red Hat would like to thank Armis Labs ( for reporting this issue.


About the author

Red Hat logo LinkedInYouTubeFacebookTwitter


구매 정보


Red Hat 소개

Red Hat은 Linux, 클라우드, 컨테이너, 쿠버네티스 등을 포함한 글로벌 엔터프라이즈 오픈소스 솔루션 공급업체입니다. Red Hat은 코어 데이터센터에서 네트워크 엣지에 이르기까지 다양한 플랫폼과 환경에서 기업의 업무 편의성을 높여 주는 강화된 기능의 솔루션을 제공합니다.

Red Hat Shares 뉴스레터를 구독하세요

지금 신청하기

언어 선택

© 2022 Red Hat, Inc. Red Hat Summit