I wouldn’t be surprised if this is actually what happened here… tech companies in general don’t delete data if they can avoid it. I worked for companies that would just set deleted = 1 in the DB on delete calls. Google has more ability than anyone else to put that data to use
I watched Jurassic Park with a live orchestra playing all the music and it was rad
I can’t say I’ve ever sent a security related bug report without at least some work done trying to understand how to fix it. Surely the caliber of people working for Project Zero can do that too, otherwise hi Google I’ll take one job please.
Wonder if they can build on top of eBPF? I think Windows is trying to implement it too
You can unlock the bootloader on a Pixel in about a minute.
I can understand some people finding the whole process a bit daunting, but it’s not actually that difficult with Graphene.
Am I misunderstanding something? Wouldn’t that just be 7! = 5040 possibilities?
What’s the give away there? Not doubting just wondering.
I see impedance matched traces so seems like something fast, but that’s all I’d be able to guess.
Seriously wtf did I just try to read? It sounded like AI slop.
The real issue is definitely people not having total control over their own devices.
It doesn’t need permissions to be sent pictures from messages though, that’s all local and likely done via an exported Service. Good chance other Google products are or will make use of it in the future.
There are definitely good, non malicious reasons to have it as a separate app and that should actually be preferred. Off the top of my head:
Some people might actually like this: thinking of women getting unsolicited dick picks in particular
This may be true, which is why you must always let the air out of your home twice a day. Still that formaldehyde is naturally occurring, and in homes come mostly from wood. So it’s not an “industry” hazard, and it’s not an artificially produced chemical.
It looks like it comes specifically from composite wood and the glues used in making those composites, not solid wood. That seems to be supported by some quick internet searching. Regular wood appears to release formaldehyde at high temperatures.
Related and interesting podcast: https://podcasts.apple.com/us/podcast/search-engine/id1614253637.
According to what he found that is somewhat the way it works: two fake candidates and the one with more yard signs got way more votes. Doubt that generalizes to the US presidency though; especially with this election.
I almost never use Windows, but aren’t commands and variables in PowerShell case insensitive?
As long as it’s installed on a device you control it’s pretty easy to sniff TLS traffic from an Android application, even if they’re pinning certs. I do this all the time for work. Frida makes it extremely easy, even giving you the ability to edit boringssl if something important is happening in native code. I’ve had to do this a couple times.
If you don’t have root you’ll have to recompile the application though which could matter if you need the signature to not change, but that isn’t a common requirement.
It’d be nice to have a better way to test though; I’ve wanted to check out Waydroid. Some coworkers just use an emulator which works great if it doesn’t need specific hardware.
Hm I always remember hearing this:
In a confidential memo to the Republican party, Luntz is credited with advising the Bush administration that the phrase “global warming” should be abandoned in favour of “climate change”, which he called a “less frightening” phrase than the former.
This is a real exploit chain in cups-browsed. The tl;dr is that it will add basically anything that knows the correct protocol to your list of available printers, and this can be exploited for RCE if you print to the malicious printer. The service listens on all interfaces by default on UDP 631.
It is not as horrible as it was marketed, but it’s real and not great. You may or may not have this service running by default; I didn’t on Fedora.
His full write-up is here: https://www.evilsocket.net/2024/09/26/Attacking-UNIX-systems-via-CUPS-Part-I/
Redox also takes some inspiration from Plan9 and https://doc.redox-os.org/book/ch05-00-schemes-resources.html is interesting. Also reading https://drewdevault.com/2022/11/12/In-praise-of-Plan-9.html made me a bit more interested in things trying to be more Plan9-like than Unix-like.
This doesn’t seem to be a Rust problem, but a modern development trend appearing in a Rust tool shipped with Cargo. The issue appears to be the way things are versioned and (reading between the lines maybe?) vendoring and/or lockfiles. Lockfiles exist in a lot of modern languages and package managers: Go has go.sum, Rust has Cargo which has Cargo.lock, Python has pip which gives a few different ways to pin versions, JavaScript has npm and yarn with lock files. I’m sure there are tons of others. I’m actually surprised this doesn’t happen all the time with newer projects. Maybe it does actually and this instance just gains traction because people get to say “look Rust bad Debian doesn’t like it”.
This seems like a big issue if you want your code to be packaged by Debian, and it doesn’t seem easy to resolve if you also want to use the modern packaging tools. I’m not actually sure how they resolve this? There are real benefits to pinning versions, but there are also real benefits to Debian’s model (of controlling all the dependencies themselves, to some extent Debian is a lockfile implemented on the OS level). Seems like a tough problem and seems like it’ll end up with a lot of newer tools just not being available in Debian (by that I mean just not packaged by Debian, they’ll likely all run fine on Debian).
I agree and think that should be helpful, but I hesitate to say how much easier that actually makes writing sound unsafe code. I’d think most experienced C developers also implicitly know when they’re doing unsafe things, with or without an unsafe block in the language – although I think the explicit unsafe should likely help code reviewers and tired developers.
It is possible to write highly unsafe code in Rust while each individual unsafe block appears sound. As a simple example: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=6a1428d9cae5b9343b464709573648b4 [1] Run that on Debug and Release builds. Notice the output is different? Don’t take that example as some sort of difficult case, you wouldn’t write this code, but the concepts in it are a bit worrisome. That code is a silly example, but each individual unsafe block appears sound when trying to reason only within the block. There is unsafe behavior happening outside of the unsafe blocks (the do_some_things function should raise eyebrows), and the function we ultimately end up in has no idea something unsafe has happened.
Unsafe code in Rust is not easy, and to some extent it breaks abstractions (maybe pointers in general break abstractions to some extent?). noaliases in that playground code rightly assumes you can’t have a &ref and &mut ref to the same thing, that’s undefined behavior in Rust. Yet to understand the cause of that bug you have to look at all function calls on the way, just as you would have to in C, and one of the biggest issues in the code exists outside of an unsafe block.
[1]: If you don’t want to click that link or it breaks, here is the code:
fn uhoh() {
let val = 9;
let val_ptr: *const usize = &val;
do_some_things(val_ptr);
println!("{}", val);
}
fn do_some_things(val: *const usize) {
let valref = unsafe { val.as_ref().unwrap() };
let mut_ptr: *mut usize = val as *mut usize;
do_some_other_things(mut_ptr, valref);
}
fn do_some_other_things(val: *mut usize, normalref: &usize) {
let mutref = unsafe { val.as_mut().unwrap() };
noaliases(normalref, mutref);
}
fn noaliases(input: &usize, output: &mut usize) {
if *input < 10 {
*output = 15;
}
if *input > 10 {
*output = 5;
}
}
fn main() {
uhoh();
}
I honestly can’t tell if this paragraph is supposed to be satirical.