Injection-capable 802.11 monitor mode on WSL2 with a 99-cent AR9271. Custom kernel, embedded firmware, one-click launcher - BicycleJunkie1971/wsl2-ar9271-monitor
Encrypting streams (27 Jun 2014) When sending data over the network, chunking is pretty much a given. TLS has a maximum record size of 16KB and this fits neatly with authenticated encryption APIs which all operate on an entire message at once. But file encryption frequently gets this wrong. Take OpenPGP: it bulk encrypts the data and sticks a single MAC on the end. Ideally everyone is decrypting to a temporary file and waiting until the decryption and verification is complete before touching the plaintext, but it takes a few seconds of searching to find people suggesting commands like this: gpg -d your_archive.tgz.gpg | tar xz With that construction, tar receives unauthenticated input and will happily extract it to the filesystem. An attacker doesn't (we assume) know the secret key, but they can guess at the structure of the plaintext and flip bits in the ciphertext. Bit flips in the ciphertext will produce a corresponding bit flip in the plaintext, followed by randomising the next block. I bet some smart attacker can do useful things with that ability. Sure the gpg command will exit with an error code, but do you think that the shell script writer carefully handled that case and undid the changes to the filesystem? The flaw here isn't in CFB mode's malleability, but in OpenPGP forcing the use of unauthenticated plaintext in practical situations. (Indeed, if you are ever thinking about the malleability of ciphertext, you have probably already lost.) I will even claim that the existance of an API that can operate in a streaming fashion over large records (i.e. will encrypt and defer the authenticator and will decrypt and return unauthenticated plaintext) is a mistake. Not only is it too easy to misunderstand and misuse (like the gpg example above) but, even if correctly buffered in a particular implementation, the existance of large records may force other implementations to do dangerous things because of a lack of buffer space. If large messages are chunked at 16KB then the overhead of sixteen bytes of authenticator for every chunk is only 0.1%. Additionally, you can safely stream the decryption (as long as you can cope with truncation of the plaintext). Although safer in general, when chunking one has to worry that an attacker hasn't reordered chunks, hasn't dropped chunks from the start and hasn't dropped chunks from the end. But sadly there's not a standard construction for taking an AEAD and making a scheme suitable for encrypting large files (AERO might be close, but it's not quite what I have in mind). Ideally such a scheme would take an AEAD and produce something very like an AEAD in that it takes a key, nonce and additional data, but can safely work in a streaming fashion. I don't think it need be very complex: take 64 bits of the nonce from the underlying AEAD as the chunk number, always start with chunk number zero and feed the additional data into chunk zero with a zero byte prefix. Prefix each chunk ciphertext with a 16 bit length and set the MSB to indicate the last chunk and authenticate that indication by setting the additional data to a single, 1 byte. The major worry might be that for many underlying AEADs, taking 64 bits of the nonce for the chunk counter leaves one with very little (or none!) left. That requires more thought before using it for real but, if you are ever building encryption-at-rest, please don't mess it up like we did 20 years ago. (Although, even with that better design, piping the output into tar may still be unwise because an attacker can truncate the stream at a chunk boundary: perhaps eliminating important files in the process.) Update: On Twitter, zooko points to Tahoe-LAFS as an example of getting it right. Additionally, taking the MAC of the current state of a digest operation and continuing the operation has been proposed for sponge functions (like SHA-3) under the name MAC-and-continue. The exact provenance of this isn't clear, but I think it might have been from the Keccak team in this paper. Although MAC-and-continue doesn't allow random access, which might be important for some situations.
A dad's storybook pipeline turned accidental benchmark: ten LLMs write the same children's book, blind-judged. Kimi K3 ties Claude Fable at 42% of the cost.
Supported by Webflow. Animate Anything - A wildly robust JavaScript animation library built for professionals.
Ever since I’ve had a website, I’ve been curious to know who is visiting it and what they do while they’re there. Am I posting into an empty space, or is som...
Syncthing mirrors your files in real time, but is that actually a good idea for dotfiles? An honest comparison against chezmoi and proper dotfile managers.
Language models typically reason via explicit chain-of-thought (CoT), generating intermediate steps token-by-token. Latent CoT offers an alternative: it performs multi-step reasoning in the model's hidden states, replacing decoded tokens with continuous representations for greater efficiency. However, existing latent CoT methods underperform explicit CoT beyond 1B parameters, and the gap widens with scale. Looped, or recurrent-depth, Transformers, which reuse their weights to increase computation depth without adding parameters, are a natural fit for latent reasoning. We therefore ask whether looped Transformers can bridge this gap. We answer affirmatively with a simple recipe: a looped padded Transformer that processes K latent blocks in parallel for R iterations, with a cross-entropy loss on each latent position's gold CoT-step token, similar to explicit CoT supervision. We instantiate it as LOTUS (Looped Transformers with parallel supervision on latents). LOTUS is, to our knowledge, the first latent-CoT method to bridge the gap to explicit CoT at the 3B scale, while cutting thought-phase latency by 2.5x-6.9x from compact math expressions to natural language. Projecting LOTUS's post-loop latents through the base LM head recovers the gold reasoning steps and even surfaces alternative valid intermediate steps, evidence that its latent space is interpretable and CoT-aligned. Ablations confirm that both the looped backbone and the parallel supervision on gold CoT tokens are essential. Code is available at https://github.com/yingfan-bot/lotus.
This issue of CCSI Investment Perspectives was contributed by Aniruddha Pravin Jaydeokar. He is a Researcher at the Columbia Center on Sustainable Investment with a focus on leveraging innovative financial structures and instruments to drive systems-level change in mining and energy value chains, as well as in the decarbonization of hard-to-abate sectors. He has done prior research in geothermal energy across Southeast Asia and North America.
It’s a long-running medical mystery: Why have so many people under 50 in affluent countries been developing colorectal cancer in recent decades?Something new is triggering a jump in what’s known as early-onset colon and rectal cancer (EOCRC). The rates have been going up for the last 20 years and no one knows why it’s happening.
Hi everyone, LinkForge recently crossed 5,000 downloads on the Blender Extensions platform, which was a nice milestone. The project started as a Blender extension for building robot models, but over time it has evolved into something a bit different: a programmable Intermediate Representation (IR) for robot descriptions. My goal isn't to replace URDF or XACRO. Instead, I see them as compilation targets, while the IR becomes the editable source model that can be validated before export. The core is written as a standalone Python engine, so it can run in Blender, from the CLI, or in automated pipelines. I'm curious what others think: Do you think robotics is missing a proper intermediate representation between CAD/design tools and formats like URDF or MJCF, or do existing workflows already solve this well? I'd genuinely appreciate feedback from people building robots professionally. GitHub: https://github.com/arounamounchili/linkforge Blender Extension: https://extensions.blender.org/add-ons/linkforge submitted by /u/Mysterious_Dare2268 [link] [Kommentare]
I have been working on this project over the past 6 months. Its a 3d printed hexapod robot dog, I call it HexaDog ZBD (English Pronunciation of ZBD means raggedy in Turkish). I used ESP32 S3 for its brains, 2x PCA9586 boards for servo connections, 18x DS3218 servos, 1x IMU, 3x 15a 300W buck converters and almost 2kg of PLA. Total robot weight is about 2.7KGs with 3s2p 18650 batteries (some sparks were created during the earlier design of the battery case) I have been testing it indoors and outdoors I am quite happy and surprised for the amount of work I got out of ESP32. I plan to convert the gait mechanism from Inverse Kinematics to a small neural network through imitation learning and run it on ESP32 as well if one core can handle the neural network while the other handles the WiFi access point and screen updates it will be golden! I have done the neural network generation from IK and controlled the robot with it in Pybullet now I have to try it on real robot. Total BoM was a close to 400 USD in Turkey (Import Taxes), but I checked on Ali and if you source them form China you can lower the costs down to about 200 USD. Amazon US prices are close to 300 USD. I plan to open source all desing files, scripts and android controller app APK. I am currently cleaning all my design files and scripts and organizing them so once I upload them there are no bugs. I wanted to get community opinion on it to see if anyone would also be interested in building one. If you wish to test it out in simulation before attempting to build one, the github repo link below contains a Pybullet demo of the robot. You can download it and control it in an empty Pybullet environment and check out the simulation script for yourself. https://github.com/serdarselimys/HexaDogZBD-PybulletDemo Let me know what you think, I wanted it to be an affordable and simple modular platform for anyone interested in robotics to experiment with it. submitted by /u/Xerd-R [link] [Kommentare]
Consumer security updates now run to October 2027, and Redmond doesn't mention Windows 11 once