Csi linux руководство

Минимальные требования к аппаратному и программному обеспечению

— 8 Гб RAM-памяти
— 70 Гб свободного места на диске
— 4-ядерный процессор
— Установленный Oracle VM Virtual Box

CSI Linux Analyst

CSI Linux Gateway

CSI Linux Gateway представляет собой пользовательский шлюз TOR, работающий в «песочнице», с использованием таких утилит как Apparmor, Jailbreak и Shorewall Firewall.

Как вы уже догадались данная виртуальная машина призвана повысить уровень анонимности и приватности при использовании дистрибутива CSI Linux Analyst.
При использовании связки CSI Linux Analyst + CSI Linux Gateway весь траффик будет пропускаться через ноду TOR.

CSI Linux SIEM

CSI Linux SIEM еще одна виртуальная машина, входящая в состав рассматриваемого дистрибутива CSI Linux Investigator. По факту представляет собой ubuntu-дистрибутив, содержащий в себе настроенный Zeek IDS и ELK Stack (elasticsearch, logstash и kibana).
Может использоваться как IDS для защиты других виртуальных машин (CSI Linux Analyst и CSI Linux Gateway), так и для работы с логами и выводом даннных на дашборды в CSI Linux Analyst.

Pulse

•

https://t.me/Pulsechanel — канал Telegram, только там дополнительные и эксклюзивные материалы, а также условия задач по OSINT.

https://hacker-basem…Читать далее

Part of the download link in the text is the server of the 1m bandwidth, the download speed is very slow, and I hope to understand.

Related Links:

• Official website:https://dhalperi.github.io/linux-80211n-csitool/
• Reference website:[Original] Linux 802.11n CSI tool mounting Ultimate Tutorial (pro-test available)、[SOLVED] Linux 802.11n CSI tool Monitor mode

Hardware device

1. Computer equipment Recommended ThinkPad X201, Recommended Purchase Link:
2. Net card must be usedIntel 5300NIC, recommended purchase link (with an antenna):

2. Brush BIOS & Disclosure Replacement NIC

Since the ThinkPad X201 computer’s BIOS version is older, I haven’t left the BIOS startup stage after I transfer the network card before, prompting the hardware device that cannot be identified. So we need to use the WIN PE system to brush a BIOS before the new card.

1. Prepare a 2G U disk, download the installer of the PE system:http://zjusdn.top:8000/static/WePE_32_V2.1.exe

2. Run the program, refresh the U disk into the boot disk of the PE system according to the instructions of the program.

3. Download the BIOS package of ThinkPad X201:http://zjusdn.top:8000/static/ThinkPad X201_6quj10us_SLIC21_no_whitelist.zip

4. Pack the BIOS package to the divided partition named «Microsoft PE Toolbox».

5. Next, insert the USB disk into the ThinkPad X201, start the power, press the ThinkVantage button while the initialization interface, then press F12 when the selection menu appears, and select the U disk in the startup menu.

6. Waiting to enter the U disk PE system, decompress the previously downloaded BIOS package within the «Microsoft PE Toolbox» partition, it is recommended to select 64-bit folders, then double-click «Winphlash64.exe» to run, click Flash Bios.

7. Wait for the brush to turn off the computer after the brush is complete, then the next is to disassemble and dress up the network.

8. Turn off the notebook power, pull out the laptop battery, do not charge the operation!

9. Unscrew the screw on the back of the pen with a cross screwder (unscrew the screw with keyboard, touchpad icon)

10. After the screws are finished, you can remove the keyboard and touchpad of your notebook.

11. The original network card is in the lower right position, we need to unscrew the screw with a screwdriver to remove the original NIC before inserting 5300 network card.

12. Since the general antenna is placed outside the notebook, it is necessary to remove the sound card board below the right to provide space for the wiring.

13. After the installation is complete, as shown below:
    

3. Operating system

The operating system recommends Ubuntu 14.06 Ltd, the kernel version is 3.13, but it seems to be only downloaded to the built-of-core version of 4.4 (mirror link:http://mirrors.zju.edu.cn/ubuntu-releases/14.04/ubuntu-14.04.6-desktop-amd64.iso）

I use the 3.13 core version of Ubuntu 14.06, the problem should be small, because the kernel is to be recompiled.

How to install the system and don’t say it. I believe everyone has no problem.

Also, if you can successfully detect the surrounding WiFi on the interface of the installation system and can be successful, then your BIOS brush is successful, the system «knows» this network card.

However, it is recommended that you install, including subsequent installation operations in the event of a cable network.

4. Nuclear compilation, drive, firmware configuration

After the operating system is installed, restart it. When you just enter the system, you may be prompted to upgrade to 16.04, click No. Including the prompt to update the software, etc.

1. Installation dependence

   • Update source

     sudo apt-get update
     

   • Download and install dependencies

     sudo apt-get -y install git-core kernel-package fakeroot build-essential ncurses-dev
     sudo apt-get -y install libnl-dev libssl-dev
     sudo apt-get -y install iw
     

2. Download, compile the kernel

   • Download Intel-5300-csi-github-master.tar.gz

     Download address: If you want to download free download: Download with my server:http://zjusdn.top:8000/static/intel-5300-csi-github-master.tar.gzIf you feel slow, here is a blogger:

   • Unzip, compile

     Step by step in order to perform the following code at the terminal

     cd ~
     tar -xvf intel-5300-csi-github-master.tar.gz
     cd intel-5300-csi-github-master.tar.gz
     make oldconfig #        
     make menuconfig # Select Save in the pop-up window, then exit, be sure to save it, not directly exit. In addition, it may be displayed because the terminal window cannot be displayed completely.
     make -j4 # Compile the kernel, it is too slow, about half an hour to an hour
     sudo make install modules_install # Install KERNEL MODULE, about 15 minutes
     sudo make install
     sudo make install modules_install # Install the kernel module again (Insurance, must be executed)
     sudo mkinitramfs -o /boot/initrd.img-`cat include/config/kernel.release` `cat include/config/kernel.release`
     make headers_install
     sudo mkdir /usr/src/linux-headers-`cat include/config/kernel.release`
     sudo cp -rf usr/include /usr/src/linux-headers-`cat include/config/kernel.release`/include
     

   • Add the original kernel (4.2.0 version) to the startup item

     cd /etc/default
     sudo vi grub
     

     This line of comments

     GRUB_HIDDEN_TIMEOUT=0
     

   • Update GRUB

     sudo update-grub
     

   • Restart the computer,for sureTo select the kernel version of 4.2 in the startup option.

3. Replace firmware

   Perform the following code in the order in order

   cd ~
   git clone git://github.com/dhalperi/linux-80211n-csitool-supplementary.git
   for file in /lib/firmware/iwlwifi-5000-*.ucode; do sudo mv $file $file.orig; done
   sudo cp linux-80211n-csitool-supplementary/firmware/iwlwifi-5000-2.ucode.sigcomm2010 /lib/firmware/
   sudo ln -s iwlwifi-5000-2.ucode.sigcomm2010 /lib/firmware/iwlwifi-5000-2.ucode
   

   At this point, the 5300 network card driver and the CSI transceiver package tool have been configured. Next, introduce the operation of the bag and the assembly.

5. Specific use

5.1 Co-prepared

Perform the following code in the terminal

cd ~
sudo apt-get install libpcap-dev
git clone https://github.com/dhalperi/lorcon-old.git
cd lorcon-old
./configure
make
sudo make install

5.2 CSI sender

1. Compile send code

   cd ~
   cd linux-80211n-csitool-supplementary/injection/
   make
   

2. Perform initialization script inject.sh (download address:http://zjusdn.top:8000/static/inject.sh）

   Before executing, you should first look at the name of the wireless network card interface, in general, WLAN0

   iwconfig
   

   as the picture shows:
   
   Execute the script is the parameter configuration:

   sudo bash ./inject.sh wlan0 64 HT20
   

   Parameter explanation: The first parameter is the name of the wireless network card interface, generally wlan0, the second parameter is the channel number, suggestion 64, the third is the HT20 mode under OFDM

   INJECT.SH code:

   #!/usr/bin/sudo /bin/bash
   sudo service network-manager stop
   WLAN_INTERFACE=$1
   SLEEP_TIME=2
   modprobe iwlwifi debug=0x40000
   if [ "$#" -ne 3 ]; then
       echo "Going to use default settings!"
       chn=64
       bw=HT20
   else
       chn=$2
       bw=$3
   fi
   sleep $SLEEP_TIME
   ifconfig $WLAN_INTERFACE 2>/dev/null 1>/dev/null
   while [ $? -ne 0 ]
   do
       ifconfig $WLAN_INTERFACE 2>/dev/null 1>/dev/null
   done
   sleep $SLEEP_TIME
   echo "Add monitor mon0....."
   iw dev $WLAN_INTERFACE interface add mon0 type monitor
   sleep $SLEEP_TIME
   echo "Bringing $WLAN_INTERFACE down....."
   ifconfig $WLAN_INTERFACE down
   while [ $? -ne 0 ]
   do
       ifconfig $WLAN_INTERFACE down
   done
   sleep $SLEEP_TIME
   echo "Bringing mon0 up....."
   ifconfig mon0 up
   while [ $? -ne 0 ]
   do
       ifconfig mon0 up
   done
   sleep $SLEEP_TIME
   echo "Set channel $chn $bw....."
   iw mon0 set channel $chn $bw
   

3. send data

   echo 0x1c113 | sudo tee `sudo find /sys -name monitor_tx_rate`
   cd ~
   cd linux-80211n-csitool-supplementary/injection/
   sudo ./random_packets 1000000000 100 1 1000
   

   The first line of parameter configuration If someone can refer to:CSI Tool Installation Explain

   However, personal suggestions will this, after all, this tool is very troublesome.

   Parameter explanation of Random_packets: The first parameter is the number of cumulative package, the second parameter is the size of the package, the third parameter 1 represents the Injection Mac, with 1, the last parameter represents a package every 1000 microseconds , 1000 packages in one second.

5.3 CSI receiving end

1. Compile reception code

   cd ~
   cd linux-80211n-csitool-supplementary/netlink/
   make
   

2. Perform initialization script monitor.sh (download address:http://zjusdn.top:8000/static/monitor.sh）

   note: Be sure to use this script, the scripts on other blogs basically lack of the second, 3 line content, otherwise they will not receive the package! I tried it several times before I found a way.

   sudo bash ./monitor.sh wlan0 64 HT20
   

   The channel number is the same as the sender

   Monitor.sh code

   #!/usr/bin/sudo /bin/bash
   sudo modprobe -r iwlwifi mac80211
   sudo modprobe iwlwifi connector_log=0x1
   
   sudo service network-manager stop
   SLEEP_TIME=2
   WLAN_INTERFACE=$1
   if [ "$#" -ne 3 ]; then
   	echo "Going to use default settings!"
   	chn=64
   	bw=HT20
   else
   	chn=$2
   	bw=$3
   fi
   echo "Bringing $WLAN_INTERFACE down......"
   ifconfig $WLANINTERFACE down
   while [ $? -ne 0 ]
   do
   	ifconfig $WLAN_INTERFACE down
   done
   sleep $SLEEP_TIME
   echo "Set $WLAN_INTERFACE into monitor mode......"
   iwconfig $WLAN_INTERFACE mode monitor
   while [ $? -ne 0 ]
   do
   	iwconfig $WLAN_INTERFACE mode monitor
   done
   sleep $SLEEP_TIME
   echo "Bringing $WLAN_INTERFACE up......"
   ifconfig $WLAN_INTERFACE up
   while [ $? -ne 0 ]
   do
   	ifconfig $WLAN_INTERFACE up
   done
   sleep $SLEEP_TIME
   echo "Set channel $chn $bw..."
   iw $WLAN_INTERFACE set channel $chn $bw
   

3. Execute a contractor

   cd ~
   cd linux-80211n-csitool-supplementary/netlink/
   sudo ./log_to_file temp # TEMP is the file name that saves the data, and strongly recommends that the file name is changed to a DAT suffix.
   

   Since the native code can only be closed, I have written a C code that can be automatically stopped after N second (download address:http://zjusdn.top:8000/static/log_to_file.c）：

   The method is as follows:

   cd ~
   cd linux-80211n-csitool-supplementary/netlink/
   sudo ./log_to_file temp 3
   

   Parameter Explanation: TEMP is the file name of saving data, and 3 represents 3 seconds from detecting the CSI package, and then exits the program. If the sender sends 1000 packs per second, 3000 packages can be received without packet loss. As shown below:
   

   Log_to_file.c file code:

   /*
    * (c) 2008-2011 Daniel Halperin <[email protected]>
    */
   #include "iwl_connector.h"
   
   #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
   #include <signal.h>
   #include <unistd.h>
   #include <arpa/inet.h>
   #include <sys/socket.h>
   #include <linux/netlink.h>
   
   #define MAX_PAYLOAD 2048
   #define SLOW_MSG_CNT 100
   
   int sock_fd = -1; // the socket
   FILE *out = NULL;
   
   void check_usage(int argc, char **argv);
   
   FILE *open_file(char *filename, char *spec);
   
   void caught_signal(int sig);
   
   void exit_program(int code);
   void exit_program_err(int code, char *func);
   void exit_program_with_alarm(int sig);
   
   int main(int argc, char **argv)
   {
   	/* Local variables */
   	struct sockaddr_nl proc_addr, kern_addr; // addrs for recv, send, bind
   	struct cn_msg *cmsg;
   	char buf[4096];
   	int ret;
   	unsigned short l, l2;
   	int count = 0;
   
   	/* Initialize signal*/
   	signal(SIGALRM, exit_program_with_alarm);
   
   	/* Make sure usage is correct */
   	check_usage(argc, argv);
   
   	/* Open and check log file */
   	out = open_file(argv[1], "w");
   
   	/* Setup the socket */
   	sock_fd = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
   	if (sock_fd == -1)
   		exit_program_err(-1, "socket");
   
   	/* Initialize the address structs */
   	memset(&proc_addr, 0, sizeof(struct sockaddr_nl));
   	proc_addr.nl_family = AF_NETLINK;
   	proc_addr.nl_pid = getpid(); // this process' PID
   	proc_addr.nl_groups = CN_IDX_IWLAGN;
   	memset(&kern_addr, 0, sizeof(struct sockaddr_nl));
   	kern_addr.nl_family = AF_NETLINK;
   	kern_addr.nl_pid = 0; // kernel
   	kern_addr.nl_groups = CN_IDX_IWLAGN;
   
   	/* Now bind the socket */
   	if (bind(sock_fd, (struct sockaddr *)&proc_addr, sizeof(struct sockaddr_nl)) == -1)
   		exit_program_err(-1, "bind");
   
   	/* And subscribe to netlink group */
   	{
   		int on = proc_addr.nl_groups;
   		ret = setsockopt(sock_fd, 270, NETLINK_ADD_MEMBERSHIP, &on, sizeof(on));
   		if (ret)
   			exit_program_err(-1, "setsockopt");
   	}
   
   	/* Set up the "caught_signal" function as this program's sig handler */
   	signal(SIGINT, caught_signal);
   
   	/* Poll socket forever waiting for a message */
   	while (1)
   	{
   		/* Receive from socket with infinite timeout */
   		ret = recv(sock_fd, buf, sizeof(buf), 0);
   		if (ret == -1)
   			exit_program_err(-1, "recv");
   		/* Pull out the message portion and print some stats */
   		cmsg = NLMSG_DATA(buf);
   		if (count % SLOW_MSG_CNT == 0)
   			printf("received %d bytes: counts: %d id: %d val: %d seq: %d clen: %dn", cmsg->len, count, cmsg->id.idx, cmsg->id.val, cmsg->seq, cmsg->len);
   		/* Log the data to file */
   		l = (unsigned short)cmsg->len;
   		l2 = htons(l);
   		fwrite(&l2, 1, sizeof(unsigned short), out);
   		ret = fwrite(cmsg->data, 1, l, out);
   		++count;
   		if (count == 1)
   		{
   			/* Set alarm */
   			alarm((*argv[2] - '0'));
   		}
   		if (ret != l)
   			exit_program_err(1, "fwrite");
   	}
   
   	exit_program(0);
   	return 0;
   }
   
   void check_usage(int argc, char **argv)
   {
   	if (argc != 3)
   	{
   		fprintf(stderr, "Usage: %s <output_file> <time>n", argv[0]);
   		exit_program(1);
   	}
   }
   
   FILE *open_file(char *filename, char *spec)
   {
   	FILE *fp = fopen(filename, spec);
   	if (!fp)
   	{
   		perror("fopen");
   		exit_program(1);
   	}
   	return fp;
   }
   
   void caught_signal(int sig)
   {
   	fprintf(stderr, "Caught signal %dn", sig);
   	exit_program(0);
   }
   
   void exit_program(int code)
   {
   	if (out)
   	{
   		fclose(out);
   		out = NULL;
   	}
   	if (sock_fd != -1)
   	{
   		close(sock_fd);
   		sock_fd = -1;
   	}
   	exit(code);
   }
   
   void exit_program_err(int code, char *func)
   {
   	perror(func);
   	exit_program(code);
   }
   
   void exit_program_with_alarm(int sig)
   {
   	exit_program(0);
   }
   

6. CSI data processing (Matlab & Python)

Matlab and Python can be processed. Personally recommend matlab, more authoritative, Python’s processing results seem to be different from MATLAB.

Both methods can convert the original data in the DAT format to the CSV format. Because the delivery and reception I use is 3 antennas, each antenna has 30 channel states, 3000 packs for one second, so the data dimension of the last CSV is 3000 * (30 * 3 * 3), that is, 3000 * 270 size .

6.1 Matlab method

1. Download the MATLAB to process the code package for the DAT file. Download link:http://zjusdn.top:8000/static/01%20dat_to_csi_mat.zip

2. Run the DATA_TO_CSI.M script in the code package.

   data_to_csi.m:

   csi_file = read_bf_file('temp.dat');
   row = size(csi_file, 1);
   temp = [];
   
   for k = 1:row
       csi = get_scaled_csi(csi_file{k});
       csi = csi(:)';
   
       for m = 1:length(csi)
           csi(m) = abs(csi(m));
       end
   
       temp = [temp; csi];
   end
   
   writematrix(temp, 'output.csv');
   

6.2 Python mode

Run the following Python code directly, pay attention to the parameters such as file paths to modify themselves.

import numpy as np
import math


class Bfee:

    def __init__(self):
        pass

    @staticmethod
    def from_file(filename, model_name_encode="shift-JIS"):

        with open(filename, "rb") as f:
            from functools import reduce
            # xiCe (function, list), add the elements in the list
            array = bytes(reduce(lambda x, y: x+y, list(f)))

        bfee = Bfee()

#         vmd.current_index = 0
        bfee.file_len = len(array)
        bfee.dicts = []
        bfee.all_csi = []

#         vmd.timestamp_low0 = int.from_bytes(array[3:7], byteorder='little', signed=False)

#         array = array[3:]

        # %% Initialize variables
        # ret = cell(ceil(len/95),1);    # % Holds the return values - 1x1 CSI is 95 bytes big, so this should be upper bound
        cur = 0                       # % Current offset into file
        count = 0                    # % Number of records output
        broken_perm = 0              # % Flag marking whether we've encountered a broken CSI yet
        # % What perm should sum to for 1,2,3 antennas
        triangle = [0, 1, 3]

        while cur < (bfee.file_len - 3):
            # % Read size and code
            #% Read file data into an array A of the dimension of Sizea, and position the file pointer to the last read value. Fread fills A in order.
            bfee.field_len = int.from_bytes(
                array[cur:cur+2], byteorder='big', signed=False)
            bfee.code = array[cur+2]
            cur = cur+3

            # there is CSI in field if code == 187，If unhandled code skip (seek over) the record and continue
            if bfee.code == 187:
                pass
            else:
                # % skip all other info
                cur = cur + bfee.field_len - 1
                continue

            # get beamforming or phy data
            if bfee.code == 187:
                count = count + 1

                bfee.timestamp_low = int.from_bytes(
                    array[cur:cur+4], byteorder='little', signed=False)
                bfee.bfee_count = int.from_bytes(
                    array[cur+4:cur+6], byteorder='little', signed=False)
                bfee.Nrx = array[cur+8]
                bfee.Ntx = array[cur+9]
                bfee.rssi_a = array[cur+10]
                bfee.rssi_b = array[cur+11]
                bfee.rssi_c = array[cur+12]
                bfee.noise = array[cur+13] - 256
                bfee.agc = array[cur+14]
                bfee.antenna_sel = array[cur+15]
                bfee.len = int.from_bytes(
                    array[cur+16:cur+18], byteorder='little', signed=False)
                bfee.fake_rate_n_flags = int.from_bytes(
                    array[cur+18:cur+20], byteorder='little', signed=False)
                bfee.calc_len = (
                    30 * (bfee.Nrx * bfee.Ntx * 8 * 2 + 3) + 6) / 8
                bfee.csi = np.zeros(
                    shape=(30, bfee.Nrx, bfee.Ntx), dtype=np.dtype(np.complex))
                bfee.perm = [1, 2, 3]
                bfee.perm[0] = ((bfee.antenna_sel) & 0x3)
                bfee.perm[1] = ((bfee.antenna_sel >> 2) & 0x3)
                bfee.perm[2] = ((bfee.antenna_sel >> 4) & 0x3)

                cur = cur + 20

                # get payload
                payload = array[cur:cur+bfee.len]
                cur = cur + bfee.len

                index = 0

                # Check that length matches what it should
                if (bfee.len != bfee.calc_len):
                    print("MIMOToolbox:read_bfee_new:size",
                          "Wrong beamforming matrix size.")

                # Compute CSI from all this crap :
                # import struct
                for i in range(30):
                    index += 3
                    remainder = index % 8
                    for j in range(bfee.Nrx):
                        for k in range(bfee.Ntx):
                            real_bin = bytes([(payload[int(index / 8)] >> remainder) | (
                                payload[int(index/8+1)] << (8-remainder)) & 0b11111111])
                            real = int.from_bytes(
                                real_bin, byteorder='little', signed=True)
                            imag_bin = bytes([(payload[int(index / 8+1)] >> remainder) | (
                                payload[int(index/8+2)] << (8-remainder)) & 0b11111111])
                            imag = int.from_bytes(
                                imag_bin, byteorder='little', signed=True)
                            tmp = np.complex(float(real), float(imag))
                            bfee.csi[i, j, k] = tmp
                            index += 16

                # % matrix does not contain default values
                if sum(bfee.perm) != triangle[bfee.Nrx-1]:
                    print('WARN ONCE: Found CSI (', filename, ') with Nrx=',
                          bfee.Nrx, ' and invalid perm=[', bfee.perm, ']n')
                else:
                    temp_csi = np.zeros(
                        bfee.csi.shape, dtype=np.dtype(np.complex))
                    # bfee.csi[:,bfee.perm[0:bfee.Nrx],:] = bfee.csi[:,0:bfee.Nrx,:]
                    for r in range(bfee.Nrx):
                        temp_csi[:, bfee.perm[r], :] = bfee.csi[:, r, :]
                    bfee.csi = temp_csi
                # Export the class attribute to DICT and return
                bfee_dict = {}
                bfee_dict['timestamp_low'] = bfee.timestamp_low
                bfee_dict['bfee_count'] = bfee.bfee_count
                bfee_dict['Nrx'] = bfee.Nrx
                bfee_dict['Ntx'] = bfee.Ntx
                bfee_dict['rssi_a'] = bfee.rssi_a
                bfee_dict['rssi_b'] = bfee.rssi_b
                bfee_dict['rssi_c'] = bfee.rssi_c
                bfee_dict['noise'] = bfee.noise
                bfee_dict['agc'] = bfee.agc
                bfee_dict['antenna_sel'] = bfee.antenna_sel
                bfee_dict['perm'] = bfee.perm
                bfee_dict['len'] = bfee.len
                bfee_dict['fake_rate_n_flags'] = bfee.fake_rate_n_flags
                bfee_dict['calc_len'] = bfee.calc_len
                bfee_dict['csi'] = bfee.csi

                bfee.dicts.append(bfee_dict)
                bfee.all_csi.append(bfee.csi)

        return bfee


def db(X, U):
    R = 1
    if 'power'.startswith(U):
        assert X >= 0
    else:
        X = math.pow(abs(X), 2) / R

    return (10 * math.log10(X) + 300) - 300


def dbinv(x):
    return math.pow(10, x / 10)


def get_total_rss(csi_st):
    # Careful here: rssis could be zero
    rssi_mag = 0
    if csi_st['rssi_a'] != 0:
        rssi_mag = rssi_mag + dbinv(csi_st['rssi_a'])
    if csi_st['rssi_b'] != 0:
        rssi_mag = rssi_mag + dbinv(csi_st['rssi_b'])
    if csi_st['rssi_c'] != 0:
        rssi_mag = rssi_mag + dbinv(csi_st['rssi_c'])
    return db(rssi_mag, 'power') - 44 - csi_st['agc']


def get_scale_csi(csi_st):
    # Pull out csi
    csi = csi_st['csi']
    # print(csi.shape)
    # print(csi)
    # Calculate the scale factor between normalized CSI and RSSI (mW)
    csi_sq = np.multiply(csi, np.conj(csi)).real
    csi_pwr = np.sum(csi_sq, axis=0)
    csi_pwr = csi_pwr.reshape(1, csi_pwr.shape[0], -1)
    rssi_pwr = dbinv(get_total_rss(csi_st))

    scale = rssi_pwr / (csi_pwr / 30)

    if csi_st['noise'] == -127:
        noise_db = -92
    else:
        noise_db = csi_st['noise']
    thermal_noise_pwr = dbinv(noise_db)

    quant_error_pwr = scale * (csi_st['Nrx'] * csi_st['Ntx'])

    total_noise_pwr = thermal_noise_pwr + quant_error_pwr
    ret = csi * np.sqrt(scale / total_noise_pwr)
    if csi_st['Ntx'] == 2:
        ret = ret * math.sqrt(2)
    elif csi_st['Ntx'] == 3:
        ret = ret * math.sqrt(dbinv(4.5))
    return ret


written_data = ''

bfee = Bfee.from_file('temp.dat', model_name_encode="gb2312")
for k in range(len(bfee.all_csi)):
    csi = get_scale_csi(bfee.dicts[k])

    for a in range(30):
        for b in range(3):
            for c in range(3):
                temp = abs(csi[a][b][c])
                written_data += str(temp) + ','
    written_data = written_data[: len(written_data) - 1] + 'n'
written_data = written_data[: len(written_data) - 1]

file = open('output.csv', mode='w')
file.write(written_data)
file.close()

Thinking I don’t say how to get the PGP public key how to generate the public key of PGP The title is okay, just go directly to the code. Method in fileutil Download Document KeybasedlargeFilePr…

Linux 802.11n CSI tool Monitor mode The disadvantage of using AP mode is that the ping command is slower and cannot accurately control the parameters sent, such as the number of packets received is un…