fix #2: do not discard trailing zero in decrypted ekey.

src/common/base64.h

@@ -4,4 +4,4 @@
 #include <cstdint>
 #include <vector>
 
-std::vector<uint8_t> b64_decode(const uint8_t *input, size_t len);
+std::vector<uint8_t> b64_decode(const uint8_t* input, size_t len);

src/jobs.hpp

@@ -59,6 +59,11 @@ class KggTask {
         }
 
         auto qmc2 = QMC2::Create(ekey);
+        if (!qmc2) {
+            error(L"create qmc2 instance failed (ekey decode error?)");
+            fprintf(stderr, "%s\n", ekey.c_str());
+            return;
+        }
 
         std::string magic(4, 0);
         kgg_stream_in.seekg(offset_to_audio, std::ios::beg);

src/qmc2/ekey.cpp

@@ -3,67 +3,59 @@
 #include "tc_tea.h"
 
 #include <algorithm>
-#include <string>
 #include <array>
+#include <string>
 #include <vector>
 
 const static std::string kEKeyV2Prefix = "UVFNdXNpYyBFbmNWMixLZXk6";
 const static std::array<uint8_t, 16> kEKeyV2Key1{
-    0x33, 0x38, 0x36, 0x5A, 0x4A, 0x59, 0x21, 0x40,
+    0x33, 0x38, 0x36, 0x5A, 0x4A, 0x59, 0x21, 0x40, 0x23, 0x2A, 0x24, 0x25, 0x5E, 0x26, 0x29, 0x28,
-    0x23, 0x2A, 0x24, 0x25, 0x5E, 0x26, 0x29, 0x28,
 };
 const static std::array<uint8_t, 16> kEKeyV2Key2{
-    0x2A, 0x2A, 0x23, 0x21, 0x28, 0x23, 0x24, 0x25,
+    0x2A, 0x2A, 0x23, 0x21, 0x28, 0x23, 0x24, 0x25, 0x26, 0x5E, 0x61, 0x31, 0x63, 0x5A, 0x2C, 0x54,
-    0x26, 0x5E, 0x61, 0x31, 0x63, 0x5A, 0x2C, 0x54,
 };
 
-template <typename T> std::span<T> ss2span(std::string_view sv) {
+template <typename T>
-  auto *data = reinterpret_cast<const T *>(sv.data());
+std::span<T> ss2span(std::string_view sv) {
-  return std::span<T>(const_cast<T *>(data), sv.size());
+    auto* data = reinterpret_cast<const T*>(sv.data());
+    return std::span<T>(const_cast<T*>(data), sv.size());
 }
 
-template <typename T> std::string_view span2ss(std::span<T> span) {
+template <typename T>
-  return std::string_view(reinterpret_cast<char *>(span.data()), span.size());
+std::string_view span2ss(std::span<T> span) {
-}
+    return std::string_view(reinterpret_cast<char*>(span.data()), span.size());
-
-void remove_trailing_zeros(std::vector<uint8_t> &vec) {
-  auto it = std::find_if(vec.rbegin(), vec.rend(),
-                         [](uint8_t value) { return value != 0; });
-  vec.erase(it.base(), vec.end());
 }
 
 std::vector<uint8_t> decrypt_ekey_v1(std::string_view ekey) {
-  std::vector<uint8_t> result =
+    std::vector<uint8_t> result = b64_decode(reinterpret_cast<const uint8_t*>(ekey.data()), ekey.size());
-      b64_decode(reinterpret_cast<const uint8_t *>(ekey.data()), ekey.size());
-  remove_trailing_zeros(result);
 
-  uint32_t tea_key[4] = {
+    uint32_t tea_key[4] = {
-      0x69005600 | static_cast<uint32_t>(result[0] << 16) | (result[1]),
+        0x69005600 | static_cast<uint32_t>(result[0] << 16) | (result[1]),
-      0x46003800 | static_cast<uint32_t>(result[2] << 16) | (result[3]),
+        0x46003800 | static_cast<uint32_t>(result[2] << 16) | (result[3]),
-      0x2b002000 | static_cast<uint32_t>(result[4] << 16) | (result[5]),
+        0x2b002000 | static_cast<uint32_t>(result[4] << 16) | (result[5]),
-      0x15000b00 | static_cast<uint32_t>(result[6] << 16) | (result[7]),
+        0x15000b00 | static_cast<uint32_t>(result[6] << 16) | (result[7]),
-  };
+    };
-  auto decrypted = tc_tea_cbc_decrypt(std::span(result).subspan(8), tea_key);
+    auto decrypted = tc_tea_cbc_decrypt(std::span(result).subspan(8), tea_key);
-  if (decrypted.empty()) {
+    if (decrypted.empty()) {
-    return {};
+        return {};
-  }
+    }
-  result.resize(8);
+    result.resize(8);
-  result.insert(result.end(), decrypted.begin(), decrypted.end());
+    result.insert(result.end(), decrypted.begin(), decrypted.end());
-  return result;
+    return result;
 }
 
 std::vector<uint8_t> decrypt_ekey_v2(std::string_view ekey) {
-  std::vector<uint8_t> result;
+    std::vector<uint8_t> result;
-  result = tc_tea_cbc_decrypt(ss2span<uint8_t>(ekey), kEKeyV2Key1.data());
+    result = tc_tea_cbc_decrypt(ss2span<uint8_t>(ekey), kEKeyV2Key1.data());
-  result = tc_tea_cbc_decrypt(std::span(result), kEKeyV2Key2.data());
+    result = tc_tea_cbc_decrypt(std::span(result), kEKeyV2Key2.data());
-  return decrypt_ekey_v1(span2ss(std::span(result)));
+    return decrypt_ekey_v1(span2ss(std::span(result)));
 }
 
 std::vector<uint8_t> decrypt_ekey(std::string_view ekey) {
-  if (ekey.starts_with(kEKeyV2Prefix)) {
+    if (ekey.starts_with(kEKeyV2Prefix)) {
-    ekey.remove_prefix(kEKeyV2Prefix.size());
+        ekey.remove_prefix(kEKeyV2Prefix.size());
-    return decrypt_ekey_v2(ekey);
+        return decrypt_ekey_v2(ekey);
-  }
+    }
 
-  return decrypt_ekey_v1(ekey);
+    return decrypt_ekey_v1(ekey);
 }

src/qmc2/qmc2_factory.cpp

@@ -4,17 +4,17 @@
 namespace QMC2 {
 
 std::unique_ptr<QMC2_Base> Create(std::string_view ekey) {
-  auto key = decrypt_ekey(ekey);
+    auto key = decrypt_ekey(ekey);
-  auto key_len = key.size();
+    auto key_len = key.size();
-  if (key_len == 0) {
+    if (key_len == 0) {
-    return nullptr;
+        return nullptr;
-  }
+    }
 
-  if (key_len < 300) {
+    if (key_len < 300) {
-    return std::make_unique<QMC2_MAP>(std::span(key));
+        return std::make_unique<QMC2_MAP>(std::span(key));
-  } else {
+    } else {
-    return std::make_unique<QMC2_RC4>(std::span(key));
+        return std::make_unique<QMC2_RC4>(std::span(key));
-  }
+    }
 }
 
-} // namespace QMC2
+}  // namespace QMC2

src/tc_tea/tc_tea.cpp

@@ -10,61 +10,62 @@ constexpr size_t kTeaBlockSize = 8;
 constexpr size_t kFixedSaltLen = 2;
 constexpr size_t kZeroPadLen = 7;
 
-inline void decrypt_round(uint8_t *p_plain, const uint8_t *p_cipher,
+inline void decrypt_round(uint8_t* p_plain,
-                          uint64_t *iv1, uint64_t *iv2, const uint32_t *key) {
+                          const uint8_t* p_cipher,
-  uint64_t iv1_next = Endian::be_u64_read(p_cipher);
+                          uint64_t* iv1,
-  uint64_t iv2_next = tc_tea_ecb_decrypt(iv1_next ^ *iv2, key);
+                          uint64_t* iv2,
-  uint64_t plain = iv2_next ^ *iv1;
+                          const uint32_t* key) {
-  *iv1 = iv1_next;
+    uint64_t iv1_next = Endian::be_u64_read(p_cipher);
-  *iv2 = iv2_next;
+    uint64_t iv2_next = tc_tea_ecb_decrypt(iv1_next ^ *iv2, key);
-  Endian::be_u64_write(p_plain, plain);
+    uint64_t plain = iv2_next ^ *iv1;
+    *iv1 = iv1_next;
+    *iv2 = iv2_next;
+    Endian::be_u64_write(p_plain, plain);
 }
 
-std::vector<uint8_t> tc_tea_cbc_decrypt(std::span<uint8_t> cipher,
+std::vector<uint8_t> tc_tea_cbc_decrypt(std::span<uint8_t> cipher, const uint32_t* key) {
-                                        const uint32_t *key) {
+    // It needs to have at least 2 blocks long, due to the nature of the padding
-  // It needs to have at least 2 blocks long, due to the nature of the padding
+    // scheme used.
-  // scheme used.
+    if (cipher.size() % kTeaBlockSize != 0 || cipher.size() < kTeaBlockSize * 2) {
-  if (cipher.size() % kTeaBlockSize != 0 || cipher.size() < kTeaBlockSize * 2) {
+        return {};
-    return {};
-  }
-
-  uint64_t iv1 = 0;
-  uint64_t iv2 = 0;
-  uint8_t header[kTeaBlockSize * 2];
-  const uint8_t *in_cipher = cipher.data();
-  decrypt_round(header, in_cipher, &iv1, &iv2, key);
-  in_cipher += kTeaBlockSize;
-  decrypt_round(header + kTeaBlockSize, in_cipher, &iv1, &iv2, key);
-  in_cipher += kTeaBlockSize;
-
-  size_t hdr_skip_len = 1 + (header[0] & 7) + kFixedSaltLen;
-  size_t real_plain_len = cipher.size() - hdr_skip_len - kZeroPadLen;
-  std::vector<uint8_t> result(real_plain_len);
-
-  auto p_output = result.data();
-
-  // copy first block of plain text
-  size_t copy_len = std::min(sizeof(header) - hdr_skip_len, real_plain_len);
-  std::copy_n(header + hdr_skip_len, real_plain_len, p_output);
-  p_output += copy_len;
-
-  if (real_plain_len != copy_len) {
-    // Decrypt the rest of the blocks
-    for (size_t i = cipher.size() - kTeaBlockSize * 3; i != 0;
-         i -= kTeaBlockSize) {
-      decrypt_round(p_output, in_cipher, &iv1, &iv2, key);
-      in_cipher += kTeaBlockSize;
-      p_output += kTeaBlockSize;
     }
 
+    uint64_t iv1 = 0;
+    uint64_t iv2 = 0;
+    uint8_t header[kTeaBlockSize * 2];
+    const uint8_t* in_cipher = cipher.data();
+    decrypt_round(header, in_cipher, &iv1, &iv2, key);
+    in_cipher += kTeaBlockSize;
     decrypt_round(header + kTeaBlockSize, in_cipher, &iv1, &iv2, key);
-    p_output[0] = header[kTeaBlockSize];
+    in_cipher += kTeaBlockSize;
-  }
-  // Validate zero padding
-  auto verify = Endian::be_u64_read(header + kTeaBlockSize) << 8;
-  if (verify != 0) {
-    result.resize(0);
-  }
 
-  return result;
+    size_t hdr_skip_len = 1 + (header[0] & 7) + kFixedSaltLen;
+    size_t real_plain_len = cipher.size() - hdr_skip_len - kZeroPadLen;
+    std::vector<uint8_t> result(real_plain_len);
+
+    auto p_output = result.data();
+
+    // copy first block of plain text
+    size_t copy_len = std::min(sizeof(header) - hdr_skip_len, real_plain_len);
+    std::copy_n(header + hdr_skip_len, real_plain_len, p_output);
+    p_output += copy_len;
+
+    if (real_plain_len != copy_len) {
+        // Decrypt the rest of the blocks
+        for (size_t i = cipher.size() - kTeaBlockSize * 3; i != 0; i -= kTeaBlockSize) {
+            decrypt_round(p_output, in_cipher, &iv1, &iv2, key);
+            in_cipher += kTeaBlockSize;
+            p_output += kTeaBlockSize;
+        }
+
+        decrypt_round(header + kTeaBlockSize, in_cipher, &iv1, &iv2, key);
+        p_output[0] = header[kTeaBlockSize];
+    }
+    // Validate zero padding
+    auto verify = Endian::be_u64_read(header + kTeaBlockSize) << 8;
+    if (verify != 0) {
+        result.resize(0);
+    }
+
+    return result;
 }

src/tc_tea/tc_tea.h

@@ -6,14 +6,12 @@
 #include <span>
 #include <vector>
 
-std::vector<uint8_t> tc_tea_cbc_decrypt(std::span<uint8_t> cipher,
+std::vector<uint8_t> tc_tea_cbc_decrypt(std::span<uint8_t> cipher, const uint32_t* key);
-                                        const uint32_t *key);
 
-inline std::vector<uint8_t> tc_tea_cbc_decrypt(std::span<uint8_t> cipher,
+inline std::vector<uint8_t> tc_tea_cbc_decrypt(std::span<uint8_t> cipher, const uint8_t* key) {
-                                               const uint8_t *key) {
+    uint32_t key_u32[4];
-  uint32_t key_u32[4];
+    for (int i = 0; i < 4; i++) {
-  for (int i = 0; i < 4; i++) {
+        key_u32[i] = Endian::be_u32_read(key + i * 4);
-    key_u32[i] = Endian::be_u32_read(key + i * 4);
+    }
-  }
+    return tc_tea_cbc_decrypt(cipher, key_u32);
-  return tc_tea_cbc_decrypt(cipher, key_u32);
 }