你是否曾擔心你的筆電Webcam在你不知情的情況下被開啟？你是否想完全掌控你的網路Webcam LED 指示燈？網路安全研究員安德烈·科諾瓦洛夫（Andrey Konovalov）近期揭露了一項技術，可以秘密關閉 ThinkPad X230 的網路Webcam LED 燈，同時還能遠端操控Webcam。這項技術涉及深入的韌體逆向工程和 USB fuzzing，在網路安全方面，fuzzing可用於測試網路協議、應用程式和嵌入式系統等各種目標的漏洞。它可以幫助識別可能被利用來破壞系統或竊取數據的錯誤和漏洞，這次測試突顯了網路Webcam安全性的潛在漏洞。
訂閱Ｔ客邦電子日報掌握最熱門的科技話題、網路動態，升級你的科技原力！
深入探索 USB Fuzzing
科諾瓦洛夫的研究始於一場漫長的機場等待。他決定利用這段時間，透過 USB fuzzing 技術測試他的 ThinkPad X230 網路Webcam。USB fuzzing 是一種測試技術，藉由發送大量異常的 USB 請求到裝置，試圖找出潛藏的漏洞。科諾瓦洛夫發現，X230 的網路Webcam可以透過 USB 進行韌體更新，意外的是，他的 fuzzer 卻破壞了Webcam的韌體，導致Webcam無法運作。
It seems like you're encountering an "Illegal instruction" error when trying to use the insightface library. This issue typically occurs when the CPU tries to execute an instruction that is not supported by the hardware, which could be due to a few potential causes. Here are some steps you can take to troubleshoot and resolve this: 1. Check CPU Architecture Compatibility
Ensure that your CPU supports the instruction sets required by insightface. For example, if you're running on an older CPU or one without certain AVX or SSE instructions, the library might fail. insightface relies on certain optimizations that may not be compatible with older hardware. You can check your CPU's capabilities by running a command like lscpu (on Linux) to see supported features.
2. Reinstall insightface and Dependencies
Sometimes, the issue can be related to incorrect installation or missing dependencies. You can try reinstalling insightface and its dependencies:
pip uninstall insightface pip install insightface
Also, make sure all other dependencies (e.g., mxnet, numpy) are up-to-date. 3. Check for the Correct Version of mxnet
insightface often relies on mxnet for its deep learning models. Ensure that the version of mxnet you are using is compatible with the version of insightface. Sometimes, using the wrong version can cause issues.
pip install mxnet==<compatible_version>
You can check the insightface documentation or the GitHub repository for version compatibility details. 4. Use a Virtual Environment
Sometimes, conflicting dependencies in your environment can cause issues. It might help to create a clean virtual environment and reinstall the necessary packages there:
Ensure your operating system and Python environment are fully up-to-date. Sometimes, kernel or system libraries can affect how certain instructions are handled.
6. Try Running on a Different Machine or Platform
If possible, test the library on a different machine or platform to see if the issue is related to your specific hardware or operating system. 7. Use Docker (Optional)
If you're working on a specific environment that may have compatibility issues, you can try running the library in a Docker container. There may be an official or community-supported Docker image that has the necessary dependencies preconfigured.
Let me know if you'd like more detailed instructions for any of these steps! You said: ~/insightface$ lscpu Architecture: x86_64 CPU op-mode(s): 32-bit, 64-bit Address sizes: 36 bits physical, 48 bits virtual Byte Order: Little Endian CPU(s): 2 On-line CPU(s) list: 0,1 Vendor ID: GenuineIntel Model name: Intel(R) Core(TM) i5-1038NG7 CPU @ 2.00GHz CPU family: 6 Model: 126 Thread(s) per core: 1 Core(s) per socket: 2 Socket(s): 1 Stepping: 5 BogoMIPS: 3993.60 Flags: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mc a cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscal l nx rdtscp lm constant_tsc nopl xtopology nonstop_tsc cpuid tsc_known_freq pni pclmulqdq ssse3 cx16 pcid sse4 _1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes f1 6c rdrand hypervisor lahf_lm abm 3dnowprefetch invpcid_ single pti fsgsbase tsc_adjust bmi1 smep bmi2 invpcid r dseed adx smap clflushopt dtherm arat pln pts Virtualization features: Hypervisor vendor: KVM Virtualization type: full Caches (sum of all): L1d: 96 KiB (2 instances) L1i: 64 KiB (2 instances) L2: 1 MiB (2 instances) L3: 6 MiB (1 instance) NUMA: NUMA node(s): 1 NUMA node0 CPU(s): 0,1 Vulnerabilities: Itlb multihit: KVM: Mitigation: VMX unsupported L1tf: Mitigation; PTE Inversion Mds: Vulnerable: Clear CPU buffers attempted, no microcode; SMT Host state unknown Meltdown: Mitigation; PTI Mmio stale data: Vulnerable: Clear CPU buffers attempted, no microcode; SMT Host state unknown Retbleed: Vulnerable Spec store bypass: Vulnerable Spectre v1: Mitigation; usercopy/swapgs barriers and __user pointer sanitization Spectre v2: Mitigation; Retpolines, STIBP disabled, RSB filling, PB RSB-eIBRS Not affected Srbds: Unknown: Dependent on hypervisor status Tsx async abort: Not affected ChatGPT said: ChatGPT
From the output of lscpu, it seems like your CPU is an Intel Core i5-1038NG7, which is relatively modern and supports several advanced instruction sets like SSE4.1, SSE4.2, and AES. However, it does not seem to support AVX or AVX2, which are often required by some deep learning libraries, including insightface when it's running on certain optimizations. Key Points:
AVX Support: Your CPU does not appear to support AVX (Advanced Vector Extensions) or AVX2 instructions, which are used by many modern machine learning libraries for improved performance, particularly for matrix operations in frameworks like mxnet and tensorflow.
Virtualization: You're running this in a virtualized environment (KVM), which may add another layer of complexity, especially if the virtualization setup is not optimized to handle advanced CPU instructions.
Possible Solutions:
Here are some ways to resolve or work around the issue: 1. Use a CPU-Compatible Version of insightface
If you're running into issues because insightface is trying to use AVX or AVX2 instructions, you could try installing a version of mxnet (the deep learning framework insightface depends on) that does not rely on AVX/AVX2 optimizations.
Try installing mxnet with no AVX support:
pip install mxnet-cu102 # Or other mxnet versions without AVX instructions.
Alternatively, you could try using a mxnet version that is compiled for lower-level optimizations, or even compile it from source with custom flags that avoid AVX instructions. 2. Try Running on a Different Machine
Since your CPU does not support AVX or AVX2, you may experience performance issues or errors when running insightface on this hardware. If possible, try running it on a more modern machine with AVX support. 3. Disable AVX in Code (if possible)
If you are comfortable with modifying the code or the underlying library (e.g., mxnet), you can try disabling AVX-specific optimizations. This can be done by setting the environment variable MXNET_CPU_FLAGS or modifying the build process.
For example, you can try:
export MXNET_CPU_FLAGS=disable_avx
This tells mxnet to avoid AVX instructions when running. Check the mxnet or insightface documentation for more information about how to disable these optimizations. 4. Run in a Docker Container (if not already)
Running the code inside a container can sometimes avoid hardware-specific issues by ensuring that the environment is consistent across machines. There might be an official insightface Docker image or a community one that has been optimized for your setup.
Here's a basic setup to run insightface in Docker:
Create a Dockerfile or use an existing one for insightface. Make sure to set up the environment correctly inside the container, possibly disabling AVX if needed.
5. Consider Using a Cloud GPU Instance
If this is a critical application and you're unable to resolve the issue on your current hardware, you could consider using a cloud instance (e.g., AWS EC2, Google Cloud, or Azure) with a more powerful CPU or even a GPU to run insightface without these hardware limitations. Final Check: Reinstall the Library
After making adjustments to the environment or architecture, you can attempt to reinstall insightface:
pip uninstall insightface pip install insightface
Let me know if you need more details or help with any of the steps above!
What does your cmd look like? It might contain a command which triggers several processes to be started. So it’s not clear which process you talk about.
Use a process group so as to enable sending a signal to all the process in the groups. For that, you should attach a session id to the parent process of the spawned/child processes, which is a shell in your case. This will make it the group leader of the processes. So now, when a signal is sent to the process group leader, it's transmitted to all of the child processes of this group.
Here's the code:
import os
import signal
import subprocess
# The os.setsid() is passed in the argument preexec_fn so# it's run after the fork() and before exec() to run the shell.
pro = subprocess.Popen(cmd, stdout=subprocess.PIPE,
shell=True, preexec_fn=os.setsid)
os.killpg(os.getpgid(pro.pid), signal.SIGTERM) # Send the signal to all the process groups
cmdlook like? It might contain a command which triggers several processes to be started. So it’s not clear which process you talk about.shell=Truemake a big difference?