fix: use utf-8 as filename encoding
This commit is contained in:
parent
348057bd09
commit
c12be04007
|
|
@ -10,6 +10,10 @@ set(WITH_ZLIB OFF)
|
|||
set(BUILD_TESTING OFF)
|
||||
add_subdirectory(taglib)
|
||||
|
||||
if(MSVC)
|
||||
add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/execution-charset:utf-8>")
|
||||
endif()
|
||||
|
||||
FILE(GLOB HEADERS ./*.h)
|
||||
FILE(GLOB SOURCES ./*.cpp)
|
||||
add_executable(ncmdump
|
||||
|
|
|
|||
20
aes.h
20
aes.h
|
|
@ -1,9 +1,10 @@
|
|||
#pragma once
|
||||
#pragma once
|
||||
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
class AES {
|
||||
class AES
|
||||
{
|
||||
|
||||
public:
|
||||
AES();
|
||||
|
|
@ -16,21 +17,21 @@ private:
|
|||
//
|
||||
int mNb;
|
||||
|
||||
//word length of the secret key used in one turn
|
||||
// word length of the secret key used in one turn
|
||||
int mNk;
|
||||
|
||||
//number of turns
|
||||
// number of turns
|
||||
int mNr;
|
||||
|
||||
//the secret key,which can be 16bytes，24bytes or 32bytes
|
||||
// the secret key,which can be 16bytes，24bytes or 32bytes
|
||||
unsigned char mKey[32];
|
||||
|
||||
//the extended key,which can be 176bytes,208bytes,240bytes
|
||||
// the extended key,which can be 176bytes,208bytes,240bytes
|
||||
unsigned char mW[60][4];
|
||||
|
||||
static unsigned char sBox[];
|
||||
static unsigned char invSBox[];
|
||||
//constant
|
||||
// constant
|
||||
static unsigned char rcon[];
|
||||
void setKey(const unsigned char *key);
|
||||
|
||||
|
|
@ -51,7 +52,6 @@ private:
|
|||
void rotWord(unsigned char w[]);
|
||||
void subWord(unsigned char w[]);
|
||||
|
||||
//get the secret key
|
||||
void getKeyAt(unsigned char key[][4],int i);
|
||||
|
||||
// get the secret key
|
||||
void getKeyAt(unsigned char key[][4], int i);
|
||||
};
|
||||
|
|
|
|||
35
main.cpp
35
main.cpp
|
|
@ -6,7 +6,7 @@
|
|||
#include <filesystem>
|
||||
|
||||
#if defined(_WIN32)
|
||||
#include <Windows.h>
|
||||
#include "platform.h"
|
||||
#endif
|
||||
|
||||
#include "color.h"
|
||||
|
|
@ -25,26 +25,26 @@ void processFile(const fs::path &filePath)
|
|||
{
|
||||
if (fs::exists(filePath) == false)
|
||||
{
|
||||
std::cerr << BOLDRED << "Error: " << RESET << "file '" << filePath.string() << "' does not exist." << std::endl;
|
||||
std::cerr << BOLDRED << "Error: " << RESET << "file '" << filePath.u8string() << "' does not exist." << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
NeteaseCrypt crypt(filePath.string());
|
||||
NeteaseCrypt crypt(filePath.u8string());
|
||||
crypt.Dump();
|
||||
crypt.FixMetadata();
|
||||
|
||||
std::cout << BOLDGREEN << "Done: '" << RESET << crypt.dumpFilepath().string() << "'" << std::endl;
|
||||
std::cout << BOLDGREEN << "Done: " << RESET << "'" << crypt.dumpFilepath().u8string() << "'" << std::endl;
|
||||
}
|
||||
catch (const std::invalid_argument &e)
|
||||
{
|
||||
std::cerr << BOLDRED << "Exception: " << RESET << RED << e.what() << RESET << " '" << filePath.string() << "'" << std::endl;
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
std::cerr << BOLDRED << "Unexpected exception while processing file: " << RESET << filePath.string() << std::endl;
|
||||
std::cerr << BOLDRED << "Exception: " << RESET << RED << e.what() << RESET << " '" << filePath.u8string() << "'" << std::endl;
|
||||
}
|
||||
// catch (...)
|
||||
// {
|
||||
// std::cerr << BOLDRED << "Unexpected exception while processing file: " << RESET << filePath.u8string() << std::endl;
|
||||
// }
|
||||
}
|
||||
|
||||
void processFilesInFolder(const fs::path &folderPath)
|
||||
|
|
@ -58,22 +58,9 @@ void processFilesInFolder(const fs::path &folderPath)
|
|||
}
|
||||
}
|
||||
|
||||
#if defined(_WIN32)
|
||||
int wmain(int argc, wchar_t *wideargv[])
|
||||
#else
|
||||
int main(int argc, char **argv)
|
||||
#endif
|
||||
{
|
||||
#if defined(_WIN32)
|
||||
SetConsoleOutputCP(CP_UTF8);
|
||||
char **argv = (char **)malloc(sizeof(char *) * argc);
|
||||
for (int i = 0; i < argc; ++i)
|
||||
{
|
||||
int utf8_size = WideCharToMultiByte(CP_UTF8, 0, wideargv[i], -1, NULL, 0, NULL, NULL);
|
||||
argv[i] = (char *)malloc(utf8_size);
|
||||
WideCharToMultiByte(CP_UTF8, 0, wideargv[i], -1, argv[i], utf8_size, NULL, NULL);
|
||||
}
|
||||
#endif
|
||||
win32_utf8argv(&argc, &argv);
|
||||
|
||||
if (argc <= 1)
|
||||
{
|
||||
|
|
@ -115,7 +102,7 @@ int main(int argc, char **argv)
|
|||
}
|
||||
else
|
||||
{
|
||||
fs::path path(argv[i]);
|
||||
fs::path path = fs::u8path(argv[i]);
|
||||
files.push_back(path);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
528
ncmcrypt.cpp
528
ncmcrypt.cpp
|
|
@ -13,338 +13,394 @@
|
|||
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
|
||||
#include <filesystem>
|
||||
|
||||
const unsigned char NeteaseCrypt::sCoreKey[17] = {0x68, 0x7A, 0x48, 0x52, 0x41, 0x6D, 0x73, 0x6F, 0x35, 0x6B, 0x49, 0x6E, 0x62, 0x61, 0x78, 0x57, 0};
|
||||
const unsigned char NeteaseCrypt::sCoreKey[17] = {0x68, 0x7A, 0x48, 0x52, 0x41, 0x6D, 0x73, 0x6F, 0x35, 0x6B, 0x49, 0x6E, 0x62, 0x61, 0x78, 0x57, 0};
|
||||
const unsigned char NeteaseCrypt::sModifyKey[17] = {0x23, 0x31, 0x34, 0x6C, 0x6A, 0x6B, 0x5F, 0x21, 0x5C, 0x5D, 0x26, 0x30, 0x55, 0x3C, 0x27, 0x28, 0};
|
||||
|
||||
const unsigned char NeteaseCrypt::mPng[8] = {0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A};
|
||||
|
||||
static void aesEcbDecrypt(const unsigned char *key, std::string& src, std::string& dst) {
|
||||
int n, i;
|
||||
static void aesEcbDecrypt(const unsigned char *key, std::string &src, std::string &dst)
|
||||
{
|
||||
int n, i;
|
||||
|
||||
unsigned char out[16];
|
||||
unsigned char out[16];
|
||||
|
||||
n = src.length() >> 4;
|
||||
n = src.length() >> 4;
|
||||
|
||||
dst.clear();
|
||||
dst.clear();
|
||||
|
||||
AES aes(key);
|
||||
AES aes(key);
|
||||
|
||||
for (i = 0; i < n-1; i++) {
|
||||
aes.decrypt((unsigned char*)src.c_str() + (i << 4), out);
|
||||
dst += std::string((char*)out, 16);
|
||||
}
|
||||
for (i = 0; i < n - 1; i++)
|
||||
{
|
||||
aes.decrypt((unsigned char *)src.c_str() + (i << 4), out);
|
||||
dst += std::string((char *)out, 16);
|
||||
}
|
||||
|
||||
aes.decrypt((unsigned char*)src.c_str() + (i << 4), out);
|
||||
char pad = out[15];
|
||||
if (pad > 16) {
|
||||
pad = 0;
|
||||
}
|
||||
dst += std::string((char*)out, 16-pad);
|
||||
aes.decrypt((unsigned char *)src.c_str() + (i << 4), out);
|
||||
char pad = out[15];
|
||||
if (pad > 16)
|
||||
{
|
||||
pad = 0;
|
||||
}
|
||||
dst += std::string((char *)out, 16 - pad);
|
||||
}
|
||||
|
||||
static void replace(std::string& str, const std::string& from, const std::string& to) {
|
||||
if(from.empty())
|
||||
return;
|
||||
size_t start_pos = 0;
|
||||
while((start_pos = str.find(from, start_pos)) != std::string::npos) {
|
||||
str.replace(start_pos, from.length(), to);
|
||||
start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
|
||||
}
|
||||
static void replace(std::string &str, const std::string &from, const std::string &to)
|
||||
{
|
||||
if (from.empty())
|
||||
return;
|
||||
size_t start_pos = 0;
|
||||
while ((start_pos = str.find(from, start_pos)) != std::string::npos)
|
||||
{
|
||||
str.replace(start_pos, from.length(), to);
|
||||
start_pos += to.length(); // In case 'to' contains 'from', like replacing 'x' with 'yx'
|
||||
}
|
||||
}
|
||||
|
||||
NeteaseMusicMetadata::~NeteaseMusicMetadata() {
|
||||
cJSON_Delete(mRaw);
|
||||
NeteaseMusicMetadata::~NeteaseMusicMetadata()
|
||||
{
|
||||
cJSON_Delete(mRaw);
|
||||
}
|
||||
|
||||
NeteaseMusicMetadata::NeteaseMusicMetadata(cJSON* raw) {
|
||||
if (!raw) {
|
||||
return;
|
||||
}
|
||||
NeteaseMusicMetadata::NeteaseMusicMetadata(cJSON *raw)
|
||||
{
|
||||
if (!raw)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
cJSON *swap;
|
||||
int artistLen, i;
|
||||
cJSON *swap;
|
||||
int artistLen, i;
|
||||
|
||||
mRaw = raw;
|
||||
mRaw = raw;
|
||||
|
||||
swap = cJSON_GetObjectItem(raw, "musicName");
|
||||
if (swap) {
|
||||
mName = std::string(cJSON_GetStringValue(swap));
|
||||
}
|
||||
swap = cJSON_GetObjectItem(raw, "musicName");
|
||||
if (swap)
|
||||
{
|
||||
mName = std::string(cJSON_GetStringValue(swap));
|
||||
}
|
||||
|
||||
swap = cJSON_GetObjectItem(raw, "album");
|
||||
if (swap) {
|
||||
mAlbum = std::string(cJSON_GetStringValue(swap));
|
||||
}
|
||||
swap = cJSON_GetObjectItem(raw, "album");
|
||||
if (swap)
|
||||
{
|
||||
mAlbum = std::string(cJSON_GetStringValue(swap));
|
||||
}
|
||||
|
||||
swap = cJSON_GetObjectItem(raw, "artist");
|
||||
if (swap) {
|
||||
artistLen = cJSON_GetArraySize(swap);
|
||||
swap = cJSON_GetObjectItem(raw, "artist");
|
||||
if (swap)
|
||||
{
|
||||
artistLen = cJSON_GetArraySize(swap);
|
||||
|
||||
i = 0;
|
||||
for (i = 0; i < artistLen-1; i++) {
|
||||
mArtist += std::string(cJSON_GetStringValue(cJSON_GetArrayItem(cJSON_GetArrayItem(swap, i), 0)));
|
||||
mArtist += "/";
|
||||
}
|
||||
mArtist += std::string(cJSON_GetStringValue(cJSON_GetArrayItem(cJSON_GetArrayItem(swap, i), 0)));
|
||||
}
|
||||
i = 0;
|
||||
for (i = 0; i < artistLen - 1; i++)
|
||||
{
|
||||
mArtist += std::string(cJSON_GetStringValue(cJSON_GetArrayItem(cJSON_GetArrayItem(swap, i), 0)));
|
||||
mArtist += "/";
|
||||
}
|
||||
mArtist += std::string(cJSON_GetStringValue(cJSON_GetArrayItem(cJSON_GetArrayItem(swap, i), 0)));
|
||||
}
|
||||
|
||||
swap = cJSON_GetObjectItem(raw, "bitrate");
|
||||
if (swap) {
|
||||
mBitrate = swap->valueint;
|
||||
}
|
||||
swap = cJSON_GetObjectItem(raw, "bitrate");
|
||||
if (swap)
|
||||
{
|
||||
mBitrate = swap->valueint;
|
||||
}
|
||||
|
||||
swap = cJSON_GetObjectItem(raw, "duration");
|
||||
if (swap) {
|
||||
mDuration = swap->valueint;
|
||||
}
|
||||
swap = cJSON_GetObjectItem(raw, "duration");
|
||||
if (swap)
|
||||
{
|
||||
mDuration = swap->valueint;
|
||||
}
|
||||
|
||||
swap = cJSON_GetObjectItem(raw, "format");
|
||||
if (swap) {
|
||||
mFormat = std::string(cJSON_GetStringValue(swap));
|
||||
}
|
||||
swap = cJSON_GetObjectItem(raw, "format");
|
||||
if (swap)
|
||||
{
|
||||
mFormat = std::string(cJSON_GetStringValue(swap));
|
||||
}
|
||||
}
|
||||
|
||||
bool NeteaseCrypt::openFile(std::filesystem::path const& path) {
|
||||
mFile.open(path, std::ios::in | std::ios::binary);
|
||||
if (!mFile.is_open()) {
|
||||
return false;
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
bool NeteaseCrypt::openFile(std::string const &path)
|
||||
{
|
||||
mFile.open(std::filesystem::u8path(path), std::ios::in | std::ios::binary);
|
||||
if (!mFile.is_open())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
else
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool NeteaseCrypt::isNcmFile() {
|
||||
unsigned int header;
|
||||
bool NeteaseCrypt::isNcmFile()
|
||||
{
|
||||
unsigned int header;
|
||||
|
||||
mFile.read(reinterpret_cast<char *>(&header), sizeof(header));
|
||||
if (header != (unsigned int)0x4e455443) {
|
||||
return false;
|
||||
}
|
||||
mFile.read(reinterpret_cast<char *>(&header), sizeof(header));
|
||||
if (header != (unsigned int)0x4e455443)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
mFile.read(reinterpret_cast<char *>(&header), sizeof(header));
|
||||
if (header != (unsigned int)0x4d414446) {
|
||||
return false;
|
||||
}
|
||||
mFile.read(reinterpret_cast<char *>(&header), sizeof(header));
|
||||
if (header != (unsigned int)0x4d414446)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
return true;
|
||||
}
|
||||
|
||||
int NeteaseCrypt::read(char *s, std::streamsize n) {
|
||||
mFile.read(s, n);
|
||||
int NeteaseCrypt::read(char *s, std::streamsize n)
|
||||
{
|
||||
mFile.read(s, n);
|
||||
|
||||
int gcount = mFile.gcount();
|
||||
int gcount = mFile.gcount();
|
||||
|
||||
if (gcount <= 0) {
|
||||
throw std::invalid_argument("Can't read file");
|
||||
}
|
||||
if (gcount <= 0)
|
||||
{
|
||||
throw std::invalid_argument("Can't read file");
|
||||
}
|
||||
|
||||
return gcount;
|
||||
return gcount;
|
||||
}
|
||||
|
||||
void NeteaseCrypt::buildKeyBox(unsigned char *key, int keyLen) {
|
||||
int i;
|
||||
for (i = 0; i < 256; ++i) {
|
||||
mKeyBox[i] = (unsigned char)i;
|
||||
}
|
||||
void NeteaseCrypt::buildKeyBox(unsigned char *key, int keyLen)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 256; ++i)
|
||||
{
|
||||
mKeyBox[i] = (unsigned char)i;
|
||||
}
|
||||
|
||||
unsigned char swap = 0;
|
||||
unsigned char c = 0;
|
||||
unsigned char last_byte = 0;
|
||||
unsigned char key_offset = 0;
|
||||
unsigned char swap = 0;
|
||||
unsigned char c = 0;
|
||||
unsigned char last_byte = 0;
|
||||
unsigned char key_offset = 0;
|
||||
|
||||
for (i = 0; i < 256; ++i)
|
||||
{
|
||||
swap = mKeyBox[i];
|
||||
c = ((swap + last_byte + key[key_offset++]) & 0xff);
|
||||
if (key_offset >= keyLen) key_offset = 0;
|
||||
mKeyBox[i] = mKeyBox[c]; mKeyBox[c] = swap;
|
||||
last_byte = c;
|
||||
}
|
||||
for (i = 0; i < 256; ++i)
|
||||
{
|
||||
swap = mKeyBox[i];
|
||||
c = ((swap + last_byte + key[key_offset++]) & 0xff);
|
||||
if (key_offset >= keyLen)
|
||||
key_offset = 0;
|
||||
mKeyBox[i] = mKeyBox[c];
|
||||
mKeyBox[c] = swap;
|
||||
last_byte = c;
|
||||
}
|
||||
}
|
||||
|
||||
std::string NeteaseCrypt::mimeType(std::string& data) {
|
||||
if (memcmp(data.c_str(), mPng, 8) == 0) {
|
||||
return std::string("image/png");
|
||||
}
|
||||
std::string NeteaseCrypt::mimeType(std::string &data)
|
||||
{
|
||||
if (memcmp(data.c_str(), mPng, 8) == 0)
|
||||
{
|
||||
return std::string("image/png");
|
||||
}
|
||||
|
||||
return std::string("image/jpeg");
|
||||
return std::string("image/jpeg");
|
||||
}
|
||||
|
||||
void NeteaseCrypt::FixMetadata() {
|
||||
if (mDumpFilepath.string().length() <= 0) {
|
||||
throw std::invalid_argument("must dump before");
|
||||
}
|
||||
void NeteaseCrypt::FixMetadata()
|
||||
{
|
||||
|
||||
TagLib::File *audioFile;
|
||||
TagLib::Tag *tag;
|
||||
TagLib::ByteVector vector(mImageData.c_str(), mImageData.length());
|
||||
TagLib::File *audioFile;
|
||||
TagLib::Tag *tag;
|
||||
TagLib::ByteVector vector(mImageData.c_str(), mImageData.length());
|
||||
|
||||
if (mFormat == NeteaseCrypt::MP3) {
|
||||
audioFile = new TagLib::MPEG::File(mDumpFilepath.c_str());
|
||||
tag = dynamic_cast<TagLib::MPEG::File*>(audioFile)->ID3v2Tag(true);
|
||||
if (mFormat == NeteaseCrypt::MP3)
|
||||
{
|
||||
audioFile = new TagLib::MPEG::File(mDumpFilepath.c_str());
|
||||
tag = dynamic_cast<TagLib::MPEG::File *>(audioFile)->ID3v2Tag(true);
|
||||
|
||||
if (mImageData.length() > 0) {
|
||||
TagLib::ID3v2::AttachedPictureFrame *frame = new TagLib::ID3v2::AttachedPictureFrame;
|
||||
if (mImageData.length() > 0)
|
||||
{
|
||||
TagLib::ID3v2::AttachedPictureFrame *frame = new TagLib::ID3v2::AttachedPictureFrame;
|
||||
|
||||
frame->setMimeType(mimeType(mImageData));
|
||||
frame->setPicture(vector);
|
||||
frame->setMimeType(mimeType(mImageData));
|
||||
frame->setPicture(vector);
|
||||
|
||||
dynamic_cast<TagLib::ID3v2::Tag*>(tag)->addFrame(frame);
|
||||
}
|
||||
} else if (mFormat == NeteaseCrypt::FLAC) {
|
||||
audioFile = new TagLib::FLAC::File(mDumpFilepath.c_str());
|
||||
tag = audioFile->tag();
|
||||
dynamic_cast<TagLib::ID3v2::Tag *>(tag)->addFrame(frame);
|
||||
}
|
||||
}
|
||||
else if (mFormat == NeteaseCrypt::FLAC)
|
||||
{
|
||||
audioFile = new TagLib::FLAC::File(mDumpFilepath.c_str());
|
||||
tag = audioFile->tag();
|
||||
|
||||
if (mImageData.length() > 0) {
|
||||
TagLib::FLAC::Picture *cover = new TagLib::FLAC::Picture;
|
||||
cover->setMimeType(mimeType(mImageData));
|
||||
cover->setType(TagLib::FLAC::Picture::FrontCover);
|
||||
cover->setData(vector);
|
||||
if (mImageData.length() > 0)
|
||||
{
|
||||
TagLib::FLAC::Picture *cover = new TagLib::FLAC::Picture;
|
||||
cover->setMimeType(mimeType(mImageData));
|
||||
cover->setType(TagLib::FLAC::Picture::FrontCover);
|
||||
cover->setData(vector);
|
||||
|
||||
dynamic_cast<TagLib::FLAC::File*>(audioFile)->addPicture(cover);
|
||||
}
|
||||
}
|
||||
dynamic_cast<TagLib::FLAC::File *>(audioFile)->addPicture(cover);
|
||||
}
|
||||
}
|
||||
|
||||
if (mMetaData != NULL) {
|
||||
tag->setTitle(TagLib::String(mMetaData->name(), TagLib::String::UTF8));
|
||||
tag->setArtist(TagLib::String(mMetaData->artist(), TagLib::String::UTF8));
|
||||
tag->setAlbum(TagLib::String(mMetaData->album(), TagLib::String::UTF8));
|
||||
}
|
||||
if (mMetaData != NULL)
|
||||
{
|
||||
tag->setTitle(TagLib::String(mMetaData->name(), TagLib::String::UTF8));
|
||||
tag->setArtist(TagLib::String(mMetaData->artist(), TagLib::String::UTF8));
|
||||
tag->setAlbum(TagLib::String(mMetaData->album(), TagLib::String::UTF8));
|
||||
}
|
||||
|
||||
tag->setComment(TagLib::String("Create by netease copyright protected dump tool. author 5L", TagLib::String::UTF8));
|
||||
tag->setComment(TagLib::String("Create by netease copyright protected dump tool. author 5L", TagLib::String::UTF8));
|
||||
|
||||
audioFile->save();
|
||||
audioFile->save();
|
||||
}
|
||||
|
||||
void NeteaseCrypt::Dump() {
|
||||
mDumpFilepath = mFilepath;
|
||||
void NeteaseCrypt::Dump()
|
||||
{
|
||||
mDumpFilepath = std::filesystem::u8path(mFilepath);
|
||||
|
||||
std::vector<unsigned char> buffer(0x8000);
|
||||
std::vector<unsigned char> buffer(0x8000);
|
||||
|
||||
std::ofstream output;
|
||||
std::ofstream output;
|
||||
|
||||
while (!mFile.eof()) {
|
||||
int n = read((char*)buffer.data(), buffer.size());
|
||||
while (!mFile.eof())
|
||||
{
|
||||
int n = read((char *)buffer.data(), buffer.size());
|
||||
|
||||
for (int i = 0; i < n; i++) {
|
||||
int j = (i + 1) & 0xff;
|
||||
buffer[i] ^= mKeyBox[(mKeyBox[j] + mKeyBox[(mKeyBox[j] + j) & 0xff]) & 0xff];
|
||||
}
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
int j = (i + 1) & 0xff;
|
||||
buffer[i] ^= mKeyBox[(mKeyBox[j] + mKeyBox[(mKeyBox[j] + j) & 0xff]) & 0xff];
|
||||
}
|
||||
|
||||
if (!output.is_open()) {
|
||||
// identify format
|
||||
// ID3 format mp3
|
||||
if (buffer[0] == 0x49 && buffer[1] == 0x44 && buffer[2] == 0x33) {
|
||||
mDumpFilepath.replace_extension(".mp3");
|
||||
mFormat = NeteaseCrypt::MP3;
|
||||
} else {
|
||||
mDumpFilepath.replace_extension(".flac");
|
||||
mFormat = NeteaseCrypt::FLAC;
|
||||
}
|
||||
if (!output.is_open())
|
||||
{
|
||||
// identify format
|
||||
// ID3 format mp3
|
||||
if (buffer[0] == 0x49 && buffer[1] == 0x44 && buffer[2] == 0x33)
|
||||
{
|
||||
mDumpFilepath = mDumpFilepath.replace_extension("mp3");
|
||||
mFormat = NeteaseCrypt::MP3;
|
||||
}
|
||||
else
|
||||
{
|
||||
mDumpFilepath = mDumpFilepath.replace_extension("flac");
|
||||
mFormat = NeteaseCrypt::FLAC;
|
||||
}
|
||||
|
||||
output.open(mDumpFilepath, output.out | output.binary);
|
||||
}
|
||||
output.open(mDumpFilepath, output.out | output.binary);
|
||||
}
|
||||
|
||||
output.write((char*)buffer.data(), n);
|
||||
}
|
||||
output.write((char *)buffer.data(), n);
|
||||
}
|
||||
|
||||
output.flush();
|
||||
output.close();
|
||||
output.flush();
|
||||
output.close();
|
||||
}
|
||||
|
||||
NeteaseCrypt::~NeteaseCrypt() {
|
||||
if (mMetaData != NULL) {
|
||||
delete mMetaData;
|
||||
}
|
||||
NeteaseCrypt::~NeteaseCrypt()
|
||||
{
|
||||
if (mMetaData != NULL)
|
||||
{
|
||||
delete mMetaData;
|
||||
}
|
||||
|
||||
mFile.close();
|
||||
mFile.close();
|
||||
}
|
||||
|
||||
NeteaseCrypt::NeteaseCrypt(std::filesystem::path const& path) {
|
||||
if (!openFile(path)) {
|
||||
throw std::invalid_argument("Can't open file");
|
||||
}
|
||||
NeteaseCrypt::NeteaseCrypt(std::string const &path)
|
||||
{
|
||||
if (!openFile(path))
|
||||
{
|
||||
throw std::invalid_argument("Can't open file");
|
||||
}
|
||||
|
||||
if (!isNcmFile()) {
|
||||
throw std::invalid_argument("Not netease protected file");
|
||||
}
|
||||
if (!isNcmFile())
|
||||
{
|
||||
throw std::invalid_argument("Not netease protected file");
|
||||
}
|
||||
|
||||
if (!mFile.seekg(2, mFile.cur)) {
|
||||
throw std::invalid_argument("Can't seek file");
|
||||
}
|
||||
if (!mFile.seekg(2, mFile.cur))
|
||||
{
|
||||
throw std::invalid_argument("Can't seek file");
|
||||
}
|
||||
|
||||
mFilepath = path;
|
||||
mFilepath = path;
|
||||
|
||||
unsigned int n;
|
||||
read(reinterpret_cast<char *>(&n), sizeof(n));
|
||||
unsigned int n;
|
||||
read(reinterpret_cast<char *>(&n), sizeof(n));
|
||||
|
||||
if (n <= 0) {
|
||||
throw std::invalid_argument("Broken NCM file");
|
||||
}
|
||||
if (n <= 0)
|
||||
{
|
||||
throw std::invalid_argument("Broken NCM file");
|
||||
}
|
||||
|
||||
std::vector<char> keydata(n);
|
||||
read(keydata.data(), n);
|
||||
std::vector<char> keydata(n);
|
||||
read(keydata.data(), n);
|
||||
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
keydata[i] ^= 0x64;
|
||||
}
|
||||
for (size_t i = 0; i < n; i++)
|
||||
{
|
||||
keydata[i] ^= 0x64;
|
||||
}
|
||||
|
||||
std::string rawKeyData(keydata.begin(), keydata.end());
|
||||
std::string mKeyData;
|
||||
std::string rawKeyData(keydata.begin(), keydata.end());
|
||||
std::string mKeyData;
|
||||
|
||||
aesEcbDecrypt(sCoreKey, rawKeyData, mKeyData);
|
||||
aesEcbDecrypt(sCoreKey, rawKeyData, mKeyData);
|
||||
|
||||
buildKeyBox((unsigned char*)mKeyData.c_str()+17, mKeyData.length()-17);
|
||||
buildKeyBox((unsigned char *)mKeyData.c_str() + 17, mKeyData.length() - 17);
|
||||
|
||||
read(reinterpret_cast<char *>(&n), sizeof(n));
|
||||
read(reinterpret_cast<char *>(&n), sizeof(n));
|
||||
|
||||
if (n <= 0) {
|
||||
std::cout << "[Warn] " << path.string() << " missing metadata infomation can't fix some infomation!" << std::endl;
|
||||
if (n <= 0)
|
||||
{
|
||||
std::cout << "[Warn] " << path << " missing metadata infomation can't fix some infomation!" << std::endl;
|
||||
|
||||
mMetaData = NULL;
|
||||
} else {
|
||||
std::vector<char> modifyData(n);
|
||||
read(modifyData.data(), n);
|
||||
mMetaData = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::vector<char> modifyData(n);
|
||||
read(modifyData.data(), n);
|
||||
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
modifyData[i] ^= 0x63;
|
||||
}
|
||||
for (size_t i = 0; i < n; i++)
|
||||
{
|
||||
modifyData[i] ^= 0x63;
|
||||
}
|
||||
|
||||
std::string swapModifyData;
|
||||
std::string modifyOutData;
|
||||
std::string modifyDecryptData;
|
||||
std::string swapModifyData;
|
||||
std::string modifyOutData;
|
||||
std::string modifyDecryptData;
|
||||
|
||||
swapModifyData = std::string(modifyData.begin() + 22, modifyData.end());
|
||||
swapModifyData = std::string(modifyData.begin() + 22, modifyData.end());
|
||||
|
||||
// escape `163 key(Don't modify):`
|
||||
Base64::Decode(swapModifyData, modifyOutData);
|
||||
// escape `163 key(Don't modify):`
|
||||
Base64::Decode(swapModifyData, modifyOutData);
|
||||
|
||||
aesEcbDecrypt(sModifyKey, modifyOutData, modifyDecryptData);
|
||||
aesEcbDecrypt(sModifyKey, modifyOutData, modifyDecryptData);
|
||||
|
||||
// escape `music:`
|
||||
modifyDecryptData = std::string(modifyDecryptData.begin()+6, modifyDecryptData.end());
|
||||
// escape `music:`
|
||||
modifyDecryptData = std::string(modifyDecryptData.begin() + 6, modifyDecryptData.end());
|
||||
|
||||
// std::cout << modifyDecryptData << std::endl;
|
||||
// std::cout << modifyDecryptData << std::endl;
|
||||
|
||||
mMetaData = new NeteaseMusicMetadata(cJSON_Parse(modifyDecryptData.c_str()));
|
||||
}
|
||||
mMetaData = new NeteaseMusicMetadata(cJSON_Parse(modifyDecryptData.c_str()));
|
||||
}
|
||||
|
||||
// skip crc32 & unuse charset
|
||||
if (!mFile.seekg(9, mFile.cur)) {
|
||||
throw std::invalid_argument("can't seek file");
|
||||
}
|
||||
// skip crc32 & unuse charset
|
||||
if (!mFile.seekg(9, mFile.cur))
|
||||
{
|
||||
throw std::invalid_argument("can't seek file");
|
||||
}
|
||||
|
||||
read(reinterpret_cast<char *>(&n), sizeof(n));
|
||||
read(reinterpret_cast<char *>(&n), sizeof(n));
|
||||
|
||||
if (n > 0) {
|
||||
char *imageData = (char*)malloc(n);
|
||||
read(imageData, n);
|
||||
if (n > 0)
|
||||
{
|
||||
char *imageData = (char *)malloc(n);
|
||||
read(imageData, n);
|
||||
|
||||
mImageData = std::string(imageData, n);
|
||||
} else {
|
||||
std::cout << "[Warn] " << path.string() << " missing album can't fix album image!" << std::endl;
|
||||
}
|
||||
mImageData = std::string(imageData, n);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << "[Warn] " << path << " missing album can't fix album image!" << std::endl;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
10
ncmcrypt.h
10
ncmcrypt.h
|
|
@ -42,7 +42,7 @@ private:
|
|||
enum NcmFormat { MP3, FLAC };
|
||||
|
||||
private:
|
||||
std::filesystem::path mFilepath;
|
||||
std::string mFilepath;
|
||||
std::filesystem::path mDumpFilepath;
|
||||
NcmFormat mFormat;
|
||||
std::string mImageData;
|
||||
|
|
@ -52,17 +52,17 @@ private:
|
|||
|
||||
private:
|
||||
bool isNcmFile();
|
||||
bool openFile(std::filesystem::path const&);
|
||||
bool openFile(std::string const&);
|
||||
int read(char *s, std::streamsize n);
|
||||
void buildKeyBox(unsigned char *key, int keyLen);
|
||||
std::string mimeType(std::string& data);
|
||||
|
||||
public:
|
||||
const std::filesystem::path& filepath() const { return mFilepath; }
|
||||
const std::filesystem::path& dumpFilepath() const { return mDumpFilepath; }
|
||||
const std::string& filepath() const { return mFilepath; }
|
||||
const std::filesystem::path dumpFilepath() const { return mDumpFilepath; }
|
||||
|
||||
public:
|
||||
NeteaseCrypt(std::filesystem::path const&);
|
||||
NeteaseCrypt(std::string const&);
|
||||
~NeteaseCrypt();
|
||||
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -0,0 +1,7 @@
|
|||
# ifdef _WIN32
|
||||
/*
|
||||
* Win32-specific argv initialization that splits OS-supplied UNICODE
|
||||
* command line string to array of UTF8-encoded strings.
|
||||
*/
|
||||
void win32_utf8argv(int *argc, char **argv[]);
|
||||
# endif
|
||||
|
|
@ -0,0 +1,296 @@
|
|||
#include <windows.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <malloc.h>
|
||||
#include "platform.h"
|
||||
|
||||
#if defined(CP_UTF8)
|
||||
|
||||
static UINT saved_cp;
|
||||
static int newargc;
|
||||
static char **newargv;
|
||||
|
||||
static void cleanup(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
SetConsoleOutputCP(saved_cp);
|
||||
|
||||
for (i = 0; i < newargc; i++)
|
||||
free(newargv[i]);
|
||||
|
||||
free(newargv);
|
||||
}
|
||||
|
||||
/*
|
||||
* Incrementally [re]allocate newargv and keep it NULL-terminated.
|
||||
*/
|
||||
static int validate_argv(int argc)
|
||||
{
|
||||
static int size = 0;
|
||||
|
||||
if (argc >= size) {
|
||||
char **ptr;
|
||||
|
||||
while (argc >= size)
|
||||
size += 64;
|
||||
|
||||
ptr = (char**)realloc(newargv, size * sizeof(newargv[0]));
|
||||
if (ptr == NULL)
|
||||
return 0;
|
||||
|
||||
(newargv = ptr)[argc] = NULL;
|
||||
} else {
|
||||
newargv[argc] = NULL;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int process_glob(WCHAR *wstr, int wlen)
|
||||
{
|
||||
int i, slash, udlen;
|
||||
WCHAR saved_char;
|
||||
WIN32_FIND_DATAW data;
|
||||
HANDLE h;
|
||||
|
||||
/*
|
||||
* Note that we support wildcard characters only in filename part
|
||||
* of the path, and not in directories. Windows users are used to
|
||||
* this, that's why recursive glob processing is not implemented.
|
||||
*/
|
||||
/*
|
||||
* Start by looking for last slash or backslash, ...
|
||||
*/
|
||||
for (slash = 0, i = 0; i < wlen; i++)
|
||||
if (wstr[i] == L'/' || wstr[i] == L'\\')
|
||||
slash = i + 1;
|
||||
/*
|
||||
* ... then look for asterisk or question mark in the file name.
|
||||
*/
|
||||
for (i = slash; i < wlen; i++)
|
||||
if (wstr[i] == L'*' || wstr[i] == L'?')
|
||||
break;
|
||||
|
||||
if (i == wlen)
|
||||
return 0; /* definitely not a glob */
|
||||
|
||||
saved_char = wstr[wlen];
|
||||
wstr[wlen] = L'\0';
|
||||
h = FindFirstFileW(wstr, &data);
|
||||
wstr[wlen] = saved_char;
|
||||
if (h == INVALID_HANDLE_VALUE)
|
||||
return 0; /* not a valid glob, just pass... */
|
||||
|
||||
if (slash)
|
||||
udlen = WideCharToMultiByte(CP_UTF8, 0, wstr, slash,
|
||||
NULL, 0, NULL, NULL);
|
||||
else
|
||||
udlen = 0;
|
||||
|
||||
do {
|
||||
int uflen;
|
||||
char *arg;
|
||||
|
||||
/*
|
||||
* skip over . and ..
|
||||
*/
|
||||
if (data.cFileName[0] == L'.') {
|
||||
if ((data.cFileName[1] == L'\0') ||
|
||||
(data.cFileName[1] == L'.' && data.cFileName[2] == L'\0'))
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!validate_argv(newargc + 1))
|
||||
break;
|
||||
|
||||
/*
|
||||
* -1 below means "scan for trailing '\0' *and* count it",
|
||||
* so that |uflen| covers even trailing '\0'.
|
||||
*/
|
||||
uflen = WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1,
|
||||
NULL, 0, NULL, NULL);
|
||||
|
||||
arg = (char*)malloc(udlen + uflen);
|
||||
if (arg == NULL)
|
||||
break;
|
||||
|
||||
if (udlen)
|
||||
WideCharToMultiByte(CP_UTF8, 0, wstr, slash,
|
||||
arg, udlen, NULL, NULL);
|
||||
|
||||
WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1,
|
||||
arg + udlen, uflen, NULL, NULL);
|
||||
|
||||
newargv[newargc++] = arg;
|
||||
} while (FindNextFileW(h, &data));
|
||||
|
||||
CloseHandle(h);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void win32_utf8argv(int *argc, char **argv[])
|
||||
{
|
||||
const WCHAR *wcmdline;
|
||||
WCHAR *warg, *wend, *p;
|
||||
int wlen, ulen, valid = 1;
|
||||
char *arg;
|
||||
|
||||
newargc = 0;
|
||||
newargv = NULL;
|
||||
if (!validate_argv(newargc))
|
||||
return;
|
||||
|
||||
wcmdline = GetCommandLineW();
|
||||
if (wcmdline == NULL) return;
|
||||
|
||||
/*
|
||||
* make a copy of the command line, since we might have to modify it...
|
||||
*/
|
||||
wlen = wcslen(wcmdline);
|
||||
p = (WCHAR*)_alloca((wlen + 1) * sizeof(WCHAR));
|
||||
wcscpy(p, wcmdline);
|
||||
|
||||
while (*p != L'\0') {
|
||||
int in_quote = 0;
|
||||
|
||||
if (*p == L' ' || *p == L'\t') {
|
||||
p++; /* skip over whitespace */
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
* Note: because we may need to fiddle with the number of backslashes,
|
||||
* the argument string is copied into itself. This is safe because
|
||||
* the number of characters will never expand.
|
||||
*/
|
||||
warg = wend = p;
|
||||
while (*p != L'\0'
|
||||
&& (in_quote || (*p != L' ' && *p != L'\t'))) {
|
||||
switch (*p) {
|
||||
case L'\\':
|
||||
/*
|
||||
* Microsoft documentation on how backslashes are treated
|
||||
* is:
|
||||
*
|
||||
* + Backslashes are interpreted literally, unless they
|
||||
* immediately precede a double quotation mark.
|
||||
* + If an even number of backslashes is followed by a double
|
||||
* quotation mark, one backslash is placed in the argv array
|
||||
* for every pair of backslashes, and the double quotation
|
||||
* mark is interpreted as a string delimiter.
|
||||
* + If an odd number of backslashes is followed by a double
|
||||
* quotation mark, one backslash is placed in the argv array
|
||||
* for every pair of backslashes, and the double quotation
|
||||
* mark is "escaped" by the remaining backslash, causing a
|
||||
* literal double quotation mark (") to be placed in argv.
|
||||
*
|
||||
* Ref: https://msdn.microsoft.com/en-us/library/17w5ykft.aspx
|
||||
*
|
||||
* Though referred page doesn't mention it, multiple qouble
|
||||
* quotes are also special. Pair of double quotes in quoted
|
||||
* string is counted as single double quote.
|
||||
*/
|
||||
{
|
||||
const WCHAR *q = p;
|
||||
int i;
|
||||
|
||||
while (*p == L'\\')
|
||||
p++;
|
||||
|
||||
if (*p == L'"') {
|
||||
int i;
|
||||
|
||||
for (i = (p - q) / 2; i > 0; i--)
|
||||
*wend++ = L'\\';
|
||||
|
||||
/*
|
||||
* if odd amount of backslashes before the quote,
|
||||
* said quote is part of the argument, not a delimiter
|
||||
*/
|
||||
if ((p - q) % 2 == 1)
|
||||
*wend++ = *p++;
|
||||
} else {
|
||||
for (i = p - q; i > 0; i--)
|
||||
*wend++ = L'\\';
|
||||
}
|
||||
}
|
||||
break;
|
||||
case L'"':
|
||||
/*
|
||||
* Without the preceding backslash (or when preceded with an
|
||||
* even number of backslashes), the double quote is a simple
|
||||
* string delimiter and just slightly change the parsing state
|
||||
*/
|
||||
if (in_quote && p[1] == L'"')
|
||||
*wend++ = *p++;
|
||||
else
|
||||
in_quote = !in_quote;
|
||||
p++;
|
||||
break;
|
||||
default:
|
||||
/*
|
||||
* Any other non-delimiter character is just taken verbatim
|
||||
*/
|
||||
*wend++ = *p++;
|
||||
}
|
||||
}
|
||||
|
||||
wlen = wend - warg;
|
||||
|
||||
if (wlen == 0 || !process_glob(warg, wlen)) {
|
||||
if (!validate_argv(newargc + 1)) {
|
||||
valid = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
ulen = 0;
|
||||
if (wlen > 0) {
|
||||
ulen = WideCharToMultiByte(CP_UTF8, 0, warg, wlen,
|
||||
NULL, 0, NULL, NULL);
|
||||
if (ulen <= 0)
|
||||
continue;
|
||||
}
|
||||
|
||||
arg = (char*)malloc(ulen + 1);
|
||||
if (arg == NULL) {
|
||||
valid = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
if (wlen > 0)
|
||||
WideCharToMultiByte(CP_UTF8, 0, warg, wlen,
|
||||
arg, ulen, NULL, NULL);
|
||||
arg[ulen] = '\0';
|
||||
|
||||
newargv[newargc++] = arg;
|
||||
}
|
||||
}
|
||||
|
||||
if (valid) {
|
||||
saved_cp = GetConsoleOutputCP();
|
||||
SetConsoleOutputCP(CP_UTF8);
|
||||
|
||||
*argc = newargc;
|
||||
*argv = newargv;
|
||||
|
||||
atexit(cleanup);
|
||||
} else if (newargv != NULL) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < newargc; i++)
|
||||
free(newargv[i]);
|
||||
|
||||
free(newargv);
|
||||
|
||||
newargc = 0;
|
||||
newargv = NULL;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
#else
|
||||
void win32_utf8argv(int *argc, char **argv[])
|
||||
{ return; }
|
||||
#endif
|
||||
Loading…
Reference in New Issue