356 lines
10 KiB
C++
356 lines
10 KiB
C++
#include <iostream>
|
|
#include <fstream>
|
|
#include <filesystem>
|
|
|
|
#include "episode.h"
|
|
|
|
#ifdef DROPOUT_DL_SQLITE
|
|
#include <sqlite3.h>
|
|
#ifdef DROPOUT_DL_GCRYPT
|
|
#include <gcrypt.h>
|
|
#endif
|
|
#endif
|
|
|
|
static int sqlite_write_callback(void* data, int argc, char** argv, char** azColName)
|
|
{
|
|
if (argc < 1) {
|
|
std::cerr << "ERROR: sqlite could not find dropout.tv cookie" << std::endl;
|
|
return -1;
|
|
}
|
|
else {
|
|
*(std::string*)data = argv[0];
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
#ifdef DROPOUT_DL_SQLITE
|
|
std::vector<std::string> get_cookies_from_firefox(const std::filesystem::path& firefox_profile_path, bool verbose = false) {
|
|
|
|
std::fstream firefox_profile_file(firefox_profile_path);
|
|
std::string firefox_profile;
|
|
|
|
std::string auth_cookie;
|
|
std::string session_cookie;
|
|
|
|
std::vector<std::string> out;
|
|
|
|
firefox_profile_file >> firefox_profile;
|
|
|
|
if (std::filesystem::is_directory(firefox_profile)) {
|
|
|
|
sqlite3 *db;
|
|
|
|
if (verbose) {
|
|
std::cout << "Getting firefox cookies from firefox sqlite db\n";
|
|
}
|
|
|
|
if (!std::filesystem::is_directory("tmp"))
|
|
std::filesystem::create_directories("tmp");
|
|
std::filesystem::remove("tmp/firefox_cookies.sqlite");
|
|
std::filesystem::copy_file(firefox_profile + "/cookies.sqlite", "tmp/firefox_cookies.sqlite");
|
|
|
|
int rc = sqlite3_open("tmp/firefox_cookies.sqlite", &db);
|
|
if (rc) {
|
|
std::cerr << "Can't open database: " << sqlite3_errmsg(db) << '\n';
|
|
exit(1);
|
|
} else {
|
|
if (verbose) {
|
|
std::cout << "Firefox database opened successfully\n";
|
|
}
|
|
}
|
|
|
|
char *err_code = nullptr;
|
|
|
|
std::string sql("SELECT value FROM moz_cookies WHERE host LIKE '%dropout.tv%' AND name='__cf_bm';");
|
|
|
|
rc = sqlite3_exec(db, sql.c_str(), sqlite_write_callback, &auth_cookie, &err_code);
|
|
|
|
out.emplace_back(auth_cookie);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
fprintf(stderr, "SQL error: %s\n", err_code);
|
|
sqlite3_free(err_code);
|
|
sqlite3_close(db);
|
|
exit(2);
|
|
} else if (verbose) {
|
|
std::cout << "Got __cf_bm cookie from firefox sqlite db\n";
|
|
}
|
|
|
|
sql = "SELECT value FROM moz_cookies WHERE host LIKE '%dropout.tv%' AND name='_session';";
|
|
|
|
rc = sqlite3_exec(db, sql.c_str(), sqlite_write_callback, &session_cookie, &err_code);
|
|
|
|
out.emplace_back(session_cookie);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
fprintf(stderr, "SQL error: %s\n", err_code);
|
|
sqlite3_free(err_code);
|
|
sqlite3_close(db);
|
|
exit(3);
|
|
} else if (verbose) {
|
|
std::cout << "Got _session cookie from firefox sqlite db\n";
|
|
}
|
|
sqlite3_close(db);
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
#ifdef DROPOUT_DL_GCRYPT
|
|
std::vector<std::string> get_cookies_from_chrome(const std::filesystem::path& chrome_profile_path, bool verbose = false) {
|
|
|
|
std::fstream chrome_profile_file(chrome_profile_path);
|
|
std::string chrome_profile;
|
|
|
|
std::string auth_cookie;
|
|
int auth_cookie_length;
|
|
std::string session_cookie;
|
|
int session_cookie_length;
|
|
|
|
std::vector<std::string> out;
|
|
|
|
getline(chrome_profile_file, chrome_profile);
|
|
|
|
if (std::filesystem::is_directory(chrome_profile)) {
|
|
|
|
sqlite3 *db;
|
|
|
|
if (verbose) {
|
|
std::cout << "Getting chrome cookies from chrome sqlite db\n";
|
|
}
|
|
|
|
int rc = sqlite3_open((chrome_profile + "/Cookies").c_str(), &db);
|
|
if (rc) {
|
|
std::cerr << "Can't open database: " << sqlite3_errmsg(db) << '\n';
|
|
exit(1);
|
|
} else {
|
|
if (verbose) {
|
|
std::cout << "Chrome database opened successfully\n";
|
|
}
|
|
}
|
|
|
|
char *err_code = nullptr;
|
|
|
|
std::string len;
|
|
|
|
std::string sql = "SELECT length(encrypted_value) FROM cookies WHERE host_key LIKE '%dropout.tv%' AND name='__cf_bm';";
|
|
|
|
sqlite3_exec(db, sql.c_str(), sqlite_write_callback, &len, &err_code);
|
|
|
|
auth_cookie_length = std::stoi(len);
|
|
|
|
sql = "SELECT encrypted_value FROM cookies WHERE host_key LIKE '%dropout.tv%' AND name='__cf_bm';";
|
|
|
|
rc = sqlite3_exec(db, sql.c_str(), sqlite_write_callback, &auth_cookie, &err_code);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
fprintf(stderr, "SQL error: %s\n", err_code);
|
|
sqlite3_free(err_code);
|
|
sqlite3_close(db);
|
|
exit(2);
|
|
} else if (verbose) {
|
|
std::cout << "Got __cf_bm cookie from chrome sqlite db\n" << auth_cookie << '\n';
|
|
}
|
|
|
|
sql = "SELECT length(encrypted_value) FROM cookies WHERE host_key LIKE '%dropout.tv%' AND name='_session';";
|
|
|
|
sqlite3_exec(db, sql.c_str(), sqlite_write_callback, &len, &err_code);
|
|
|
|
session_cookie_length = std::stoi(len);
|
|
|
|
sql = "SELECT encrypted_value FROM cookies WHERE host_key LIKE '%dropout.tv%' AND name='_session';";
|
|
|
|
rc = sqlite3_exec(db, sql.c_str(), sqlite_write_callback, &session_cookie, &err_code);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
fprintf(stderr, "SQL error: %s\n", err_code);
|
|
sqlite3_free(err_code);
|
|
sqlite3_close(db);
|
|
exit(3);
|
|
} else if (verbose) {
|
|
std::cout << "Got _session cookie from chrome sqlite db\n";
|
|
}
|
|
sqlite3_close(db);
|
|
|
|
// system(("echo \"SELECT value FROM moz_cookies WHERE originAttributes LIKE '%dropout.tv%';\" | sqlite3 " + firefox_profile + "/cookies.sqlite > cookie").c_str());
|
|
}
|
|
|
|
// For mac os this is your keychain password
|
|
// For linux leave as "peanuts"
|
|
std::string password = "peanuts";
|
|
std::string salt = "saltysalt";
|
|
int length = 16;
|
|
int iterations = 1;
|
|
|
|
uint8_t key[32];
|
|
|
|
char output[2048];
|
|
|
|
char iv[16];
|
|
|
|
for (char& c : iv) {
|
|
c = ' ';
|
|
}
|
|
|
|
for (char& c : output) {
|
|
c = 0;
|
|
}
|
|
|
|
for (int i = 0; i < auth_cookie_length; i++) {
|
|
std::cout << std::hex << (0xFF & (int)auth_cookie[i]) << ' ';
|
|
}
|
|
std::cout << '\n';
|
|
|
|
gcry_kdf_derive(password.c_str(), password.size(), GCRY_KDF_PBKDF2, GCRY_KDF_ARGON2ID, salt.c_str(), salt.size(), iterations, length, key);
|
|
|
|
gcry_cipher_hd_t handle;
|
|
|
|
gcry_cipher_open(&handle, GCRY_CIPHER_AES, GCRY_CIPHER_MODE_CBC, 0);
|
|
|
|
gcry_cipher_setkey(handle, (const void*) &key, length);
|
|
|
|
gcry_cipher_setiv(handle, (const void*)&iv, 16);
|
|
|
|
unsigned long err = gcry_cipher_decrypt(handle, (unsigned char*)output, 2048, auth_cookie.c_str() + 3, auth_cookie_length - 3);
|
|
|
|
if (err) {
|
|
std::cout << gcry_strerror(err) << std::endl;
|
|
exit(2);
|
|
}
|
|
|
|
for (char& c : output) {
|
|
if (c == '\017') {
|
|
c = 0;
|
|
}
|
|
}
|
|
|
|
out.emplace_back(output);
|
|
|
|
gcry_cipher_setiv(handle, (const void*)&iv, 16);
|
|
|
|
gcry_cipher_decrypt(handle, (unsigned char*)output, 2048, session_cookie.c_str() + 3, session_cookie_length - 3);
|
|
|
|
out.emplace_back(output);
|
|
|
|
return out;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
std::vector<std::string> get_cookies_from_files(const std::filesystem::path& auth_cookie_path, const std::filesystem::path& session_cookie_path, bool verbose = false) {
|
|
std::fstream auth_cookie_file("auth_cookie");
|
|
std::fstream session_cookie_file("session_cookie");
|
|
|
|
std::string auth_cookie;
|
|
std::string session_cookie;
|
|
|
|
std::vector<std::string> out;
|
|
|
|
auth_cookie_file >> auth_cookie;
|
|
if (verbose) {
|
|
std::cout << "Got __cf_bm cookie from auth_cookie file db\n";
|
|
}
|
|
|
|
out.emplace_back(auth_cookie);
|
|
|
|
session_cookie_file >> session_cookie;
|
|
if (verbose) {
|
|
std::cout << "Got _session cookie from auth_cookie file db\n";
|
|
}
|
|
|
|
out.emplace_back(session_cookie);
|
|
|
|
return out;
|
|
}
|
|
|
|
std::vector<std::string> get_cookies(bool verbose = false) {
|
|
|
|
#ifdef DROPOUT_DL_SQLITE
|
|
std::filesystem::path firefox_profile("firefox_profile");
|
|
#ifdef DROPOUT_DL_GCRYPT
|
|
std::filesystem::path chrome_profile("chrome_profile");
|
|
#endif
|
|
#endif
|
|
std::filesystem::path auth_cookie("auth_cookie");
|
|
std::filesystem::path session_cookie("session_cookie");
|
|
|
|
|
|
#ifdef DROPOUT_DL_SQLITE
|
|
if (std::filesystem::exists(firefox_profile)) {
|
|
return get_cookies_from_firefox(firefox_profile, verbose);
|
|
} else
|
|
#ifdef DROPOUT_DL_GCRYPT
|
|
if (std::filesystem::exists(chrome_profile)) {
|
|
return get_cookies_from_chrome(chrome_profile, verbose);
|
|
} else
|
|
#endif
|
|
#endif
|
|
if (std::filesystem::exists(auth_cookie) && std::filesystem::exists(session_cookie)){
|
|
return get_cookies_from_files(auth_cookie, session_cookie, verbose);
|
|
}
|
|
else {
|
|
std::cerr << "ERROR: dropout.tv cookies could not be found" << std::endl;
|
|
exit(7);
|
|
}
|
|
}
|
|
|
|
|
|
int main(int argc, char** argv) {
|
|
|
|
bool verbose = false;
|
|
std::string quality = "all";
|
|
|
|
std::string firefox_profile;
|
|
std::string chrome_profile;
|
|
|
|
std::string episode_url;
|
|
|
|
std::vector<std::string> cookies;
|
|
|
|
std::string video_data;
|
|
|
|
if (argc > 1) {
|
|
episode_url = argv[1];
|
|
if (verbose) {
|
|
std::cout << "Got episode url: " << episode_url << " from program arguments\n";
|
|
}
|
|
}
|
|
else {
|
|
std::cout << "Enter episode url: ";
|
|
std::cin >> episode_url;
|
|
}
|
|
|
|
cookies = get_cookies(verbose);
|
|
|
|
dropout_dl::episode ep(episode_url, cookies, verbose);
|
|
|
|
if (!std::filesystem::is_directory(ep.series)) {
|
|
std::filesystem::create_directories(ep.series);
|
|
if (verbose) {
|
|
std::cout << "Creating series directory" << '\n';
|
|
}
|
|
}
|
|
|
|
if (quality == "all") {
|
|
for (const auto& possible_quality : ep.qualities) {
|
|
if (!std::filesystem::is_directory(ep.series + "/" + possible_quality)) {
|
|
std::filesystem::create_directories(ep.series + "/" + possible_quality);
|
|
if (verbose) {
|
|
std::cout << "Creating series directory" << '\n';
|
|
}
|
|
}
|
|
std::fstream out(ep.series + "/" + possible_quality + "/" + ep.filename,
|
|
std::ios_base::in | std::ios_base::out | std::ios_base::trunc);
|
|
|
|
out << ep.get_video_data(possible_quality) << std::endl;
|
|
}
|
|
}
|
|
else {
|
|
std::fstream out(ep.series + "/" + ep.filename, std::ios_base::in | std::ios_base::out | std::ios_base::trunc);
|
|
|
|
out << ep.get_video_data(quality) << std::endl;
|
|
}
|
|
|
|
return 0;
|
|
}
|