widevine-l3-guesser
DISCONTINUED
rust
Our great sponsors
widevine-l3-guesser | rust | |
---|---|---|
18 | 2674 | |
547 | 91,922 | |
- | 2.8% | |
5.7 | 10.0 | |
over 2 years ago | 3 days ago | |
C | Rust | |
MIT License | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
widevine-l3-guesser
-
How to download videos from paid streaming services I have a subscription to for offline viewing?
If they have DRM you need to find the keys using a Widevine Guesser, then download the encrypted file and decrypt it using either ffmpeg or mp4decrypt.
-
Widevine L3 Decryptor/Guesser
the widevinedumper script is a bit tricky, would be easier if you download the code for widevine-l3-guesser, open the content_key_decryption.js file, on line 106 you should see this, edit it with your own key, then add the extension to chrome
-
How can I download Udemy courses from my Udemy Business account?
If the course doesn't use DRM then https://github.com/r0oth3x49/udemy-dl otherwise https://github.com/Puyodead1/udemy-downloader and https://github.com/Satsuoni/widevine-l3-guesser with downgraded CDM to 2209 (might stop working on Udemy in the future though, but it still works for now)
-
Best way to download Udemy courses?
only downside is that you have to provide the decryption keys, the main way was using this extension https://github.com/Satsuoni/widevine-l3-guesser but google updated their DRM recently which broke it, not sure if it still works on udemy if you downgrade to the old CDM version or not.
-
Psst: Fast Spotify client with native GUI, without Electron, built in Rust
> Is that even possible for Spotify at this point?
Spotify are using Widevine on their web client, which is considerably more annoying to deal with than the encryption method used in the files fetched by Psst.
Nothing is stopping them from only serving files from the endpoint that serves Widevine protected files.
Then again, Widevine L3 has been broken[0], Google just keeps rotating the private keys used in the content decryption module.
- Widevine l3 has been cracked wide open once again!
-
How to Rip From Amazon & Other Streaming Services Losslessly (again)
Fast forward to today and someone managed to find a way to brute force the Widevine keys again, on the latest version of chrome. You can find the new extension from here. If the GitHub repo gets taken down/dmca'd it is also saved in the Wayback Machine. The new extension brute forces the keys, so it will take around 15 minutes to get.
The widevine l3 guesser extension is linked here and also around the beginning of the post. You can download mp4decryptor from here. To install the extension, read the first tutorial (installing the extension.) To install mp4decryptor, you just need to extract the .zip you downloaded, then go into the extracted folder & into the bin folder, and then copy the "mp4decrypt.exe" file to the same folder with the encrypted mp4.
rust
-
What Are Const Generics and How Are They Used in Rust?
The above Assert<{N % 2 == 1}> requires #![feature(generic_const_exprs)] and the nightly toolchain. See https://github.com/rust-lang/rust/issues/76560 for more info.
-
Algorithms for Modern Hardware
There’s also other reasons. For example, take binary search:
* prefetch + cmov. These should be part of the STL but languages and compilers struggle to emit the cmov properly (Rust’s been broken for 6 years: https://github.com/rust-lang/rust/issues/53823). Prefetch is an interesting one because while you do optimize the binary search in a micro benchmark, you’re potentially putting extra pressure on the cache with “garbage” data which means it’s a greedy optimization that might hurt surrounding code. Probably should have separate implementations as binary search isn’t necessarily always in the hot path.
* Eytzinger layout has additional limitations that are often not discussed when pointing out “hey this is faster”. Adding elements is non-trivial since you first have to add + sort (as you would for binary search) and then rebuild a new parallel eytzinger layout from scratch (i.e. you’d have it be an index of pointers rather than the values themselves which adds memory overhead + indirection for the comparisons). You can’t find the “insertion” position for non-existent elements which means it can’t be used for std::lower_bound (i.e. if the element doesn’t exist, you just get None back instead of Err(position where it can be slotted in to maintain order).
Basically, optimizations can sometimes rely on changing the problem domain so that you can trade off features of the algorithm against the runtime. These kinds of algorithms can be a bad fit for a standard library which aims to be a toolbox of “good enough” algorithms and data structures for problems that appear very very frequently. Or they could be part of the standard library toolkit just under a different name but you also have to balance that against maintenance concerns.
- Rust: Actix-web and Daily Logging
-
Groovy 🎷 Cheat Sheet - 01 Say "Hello" from Groovy
But that said, - and again I might be a bit biased - Groovy is too slow for me! I compared it to Rust in this LinkedIn post and it was waaaaay slow. Keep in mind that subjectively comparing programming languages might be a tricky business. But at the end, it will be up to your use case/project to prefer a language over the other.
-
Top Paying Programming Technologies 2024
13. Rust - $87,012
-
Dada, an Experiement by the Creators of Rust
Yes, actually.
https://github.com/rust-lang/rust/blob/d0ea1d767925d53b2230e...
Limited to the rust codebase itself, but I'm sure the developers would force it on everyone else if they thought they could get away with it.
-
7 Programming Languages Every Cloud Engineer Should Know in 2024!
Rust is gaining momentum in the cloud computing domain due to its emphasis on safety, speed, and concurrency without a garbage collector. These features make Rust an appealing choice for cloud engineers looking to develop high-performance, secure, and reliable cloud services and infrastructure. Rust's memory safety guarantees and efficient compilation to machine code position it as an ideal language for system-level and embedded applications in cloud environments, where performance and security are paramount.
-
Borrow Checking Without Lifetimes
> I'm not sure what's neutered about Rust's current plans for generators
They're neutered because they can't suspend and transfer control to a function other than the one that called them ("Note also that "coroutines" here are really "semicoroutines" since they can only yield back to their caller." https://lang-team.rust-lang.org/design_notes/general_corouti...) and you can't pass values into resume and get them out from the yield statement in the coroutine (https://github.com/rust-lang/rust/issues/43122#issuecomment-...).
> and they aren't separate from async, they're the foundation that async desugars to.
Yeah I just looked it up again and I don't know why I had it in my head that they were separate, you're correct, they are the same thing under the hood, so honestly that eliminates my biggest problem with them.
> 'm also not sure what your objection is to Polonius, which, so far, is still just a strictly more permissive version of the borrow checker, with nothing new to learn on the user end.
The entire model is different under the hood, though, since it switches from lifetimes+borrows to loans, and so in order to fully understand its behavior the user really would have to change their mental model, and as I said above I'm a huge fan of the lifetimes model and less so of the loan model. I just feel like it's much more natural to treat the ownership of a memory object and therefore amount of time in your code that object lives as the fixed point, and borrows as wrong for outliving what they refer to, then to treat borrows as the fixed point, and objects as wrong for going out of scope and being dropped before the borrow ends, because the fundamental memory management model of Rust is single ownership of objects, moves, and scope based RAII via Drop, so the lifetime of an object kind of is the more basic building block of the memory model, with borrows sort of conceptually orbiting around that and naturally being adjusted to fit that, with the checker being a way to force you to adhere to that. The loan based way of thinking would make more sense for an ARC-based language where references actually are more basic because objects really do only live for as long as there are references to them.
> you can't pass values into resume and get them out from the yield statement in the coroutine
I think that the linked comment is out of date, and that this is supported now (hard to tell because it hasn't been close enough to stabilization to be properly documented): https://github.com/rust-lang/rust/pull/68524
As for Polonius changing the underlying mental model, I think this is a natural progression. Rust 1.0 tried to present a simple lexical model of borrowing, and then enough people complained that it has long since replaced the simple model with non-lexical lifetimes in order to trade simplicity for "do what I mean". And since it's not allowed to break any old code, if you want to continue treating borrowing like it has the previous model then that shouldn't present any difficulties.
-
Why do we need for an Undefined Behavior Annex to C++
I don't see where those methods are getting called from a Unix signal handler but the code is complex enough that it's easy to miss, especially perusing through github instead of vscode.
AFAICT those methods are called from `guard::current`. In turn, `guard::current` is used to initialize TLS data when a thread is spawned before a signal is generated (& right after the signal handler is installed): https://github.com/rust-lang/rust/blob/26907374b9478d84d766a...
It doesn't look like there's any UB behavior being relied upon but I could very easily be misreading. If I missed it, please give me some more pointers cause this should be a github issue if it's the case - calling non async-safe methods from a signal handler typically can result in a deadlock which is no bueno.
What are some alternatives?
carbon-lang - Carbon Language's main repository: documents, design, implementation, and related tools. (NOTE: Carbon Language is experimental; see README)
N_m3u8DL-CLI - [.NET] m3u8 downloader 开源的命令行m3u8/HLS/dash下载器,支持普通AES-128-CBC解密,多线程,自定义请求头等. 支持简体中文,繁体中文和英文. English Supported.
widevine-l3-decryptor - Mirror of the original repo
widevine-L3-WEB-DL-Script - This is a batch script created to WEB-DL.
udemy-downloader - A Udemy downloader that can download lectures, with DRM support.
udemy-dl - A cross-platform python based utility to download courses from udemy for personal offline use.
zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.
dumper - Dump L3 CDM from any Android device
Nim - Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula. Its design focuses on efficiency, expressiveness, and elegance (in that order of priority).
Odin - Odin Programming Language
Elixir - Elixir is a dynamic, functional language for building scalable and maintainable applications
psst - Fast and multi-platform Spotify client with native GUI