cli/algo/ncm/ncm.go

240 lines
5.5 KiB
Go

package ncm
import (
"bytes"
"context"
"encoding/base64"
"encoding/binary"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"strings"
"unlock-music.dev/cli/algo/common"
"unlock-music.dev/cli/internal/utils"
)
const magicHeader = "CTENFDAM"
var (
keyCore = []byte{
0x68, 0x7a, 0x48, 0x52, 0x41, 0x6d, 0x73, 0x6f,
0x35, 0x6b, 0x49, 0x6e, 0x62, 0x61, 0x78, 0x57,
}
keyMeta = []byte{
0x23, 0x31, 0x34, 0x6C, 0x6A, 0x6B, 0x5F, 0x21,
0x5C, 0x5D, 0x26, 0x30, 0x55, 0x3C, 0x27, 0x28,
}
)
func NewDecoder(rd io.ReadSeeker) common.Decoder {
return &Decoder{
rd: rd,
}
}
type Decoder struct {
rd io.ReadSeeker // rd is the original file reader
offset int
cipher common.StreamDecoder
metaRaw []byte
metaType string
meta RawMeta
cover []byte
}
// Validate checks if the file is a valid Netease .ncm file.
// rd will be seeked to the beginning of the encrypted audio.
func (d *Decoder) Validate() error {
if err := d.validateMagicHeader(); err != nil {
return err
}
if _, err := d.rd.Seek(2, io.SeekCurrent); err != nil { // 2 bytes gap
return fmt.Errorf("ncm seek file: %w", err)
}
keyData, err := d.readKeyData()
if err != nil {
return err
}
if err := d.readMetaData(); err != nil {
return fmt.Errorf("read meta date failed: %w", err)
}
if _, err := d.rd.Seek(5, io.SeekCurrent); err != nil { // 5 bytes gap
return fmt.Errorf("ncm seek gap: %w", err)
}
if err := d.readCoverData(); err != nil {
return fmt.Errorf("parse ncm cover file failed: %w", err)
}
if err := d.parseMeta(); err != nil {
return fmt.Errorf("parse meta failed: %w", err)
}
d.cipher = newNcmCipher(keyData)
return nil
}
func (d *Decoder) validateMagicHeader() error {
header := make([]byte, len(magicHeader)) // 0x00 - 0x07
if _, err := d.rd.Read(header); err != nil {
return fmt.Errorf("ncm read magic header: %w", err)
}
if !bytes.Equal([]byte(magicHeader), header) {
return errors.New("ncm magic header not match")
}
return nil
}
func (d *Decoder) readKeyData() ([]byte, error) {
bKeyLen := make([]byte, 4) //
if _, err := io.ReadFull(d.rd, bKeyLen); err != nil {
return nil, fmt.Errorf("ncm read key length: %w", err)
}
iKeyLen := binary.LittleEndian.Uint32(bKeyLen)
bKeyRaw := make([]byte, iKeyLen)
if _, err := io.ReadFull(d.rd, bKeyRaw); err != nil {
return nil, fmt.Errorf("ncm read key data: %w", err)
}
for i := uint32(0); i < iKeyLen; i++ {
bKeyRaw[i] ^= 0x64
}
return utils.PKCS7UnPadding(utils.DecryptAES128ECB(bKeyRaw, keyCore))[17:], nil
}
func (d *Decoder) readMetaData() error {
bMetaLen := make([]byte, 4) //
if _, err := io.ReadFull(d.rd, bMetaLen); err != nil {
return fmt.Errorf("ncm read key length: %w", err)
}
iMetaLen := binary.LittleEndian.Uint32(bMetaLen)
if iMetaLen == 0 {
return nil // no meta data
}
bMetaRaw := make([]byte, iMetaLen)
if _, err := io.ReadFull(d.rd, bMetaRaw); err != nil {
return fmt.Errorf("ncm read meta data: %w", err)
}
bMetaRaw = bMetaRaw[22:] // skip "163 key(Don't modify):"
for i := 0; i < len(bMetaRaw); i++ {
bMetaRaw[i] ^= 0x63
}
cipherText, err := base64.StdEncoding.DecodeString(string(bMetaRaw))
if err != nil {
return errors.New("decode ncm meta failed: " + err.Error())
}
metaRaw := utils.PKCS7UnPadding(utils.DecryptAES128ECB(cipherText, keyMeta))
sep := bytes.IndexByte(metaRaw, ':')
if sep == -1 {
return errors.New("invalid ncm meta file")
}
d.metaType = string(metaRaw[:sep])
d.metaRaw = metaRaw[sep+1:]
return nil
}
func (d *Decoder) readCoverData() error {
bCoverCRC := make([]byte, 4)
if _, err := io.ReadFull(d.rd, bCoverCRC); err != nil {
return fmt.Errorf("ncm read cover crc: %w", err)
}
bCoverLen := make([]byte, 4) //
if _, err := io.ReadFull(d.rd, bCoverLen); err != nil {
return fmt.Errorf("ncm read cover length: %w", err)
}
iCoverLen := binary.LittleEndian.Uint32(bCoverLen)
coverBuf := make([]byte, iCoverLen)
if _, err := io.ReadFull(d.rd, coverBuf); err != nil {
return fmt.Errorf("ncm read cover data: %w", err)
}
d.cover = coverBuf
return nil
}
func (d *Decoder) parseMeta() error {
switch d.metaType {
case "music":
d.meta = new(RawMetaMusic)
return json.Unmarshal(d.metaRaw, d.meta)
case "dj":
d.meta = new(RawMetaDJ)
return json.Unmarshal(d.metaRaw, d.meta)
default:
return errors.New("unknown ncm meta type: " + d.metaType)
}
}
func (d *Decoder) Read(buf []byte) (int, error) {
n, err := d.rd.Read(buf)
if n > 0 {
d.cipher.Decrypt(buf[:n], d.offset)
d.offset += n
}
return n, err
}
func (d *Decoder) GetAudioExt() string {
if d.meta != nil {
if format := d.meta.GetFormat(); format != "" {
return "." + d.meta.GetFormat()
}
}
return ""
}
func (d *Decoder) GetCoverImage(ctx context.Context) ([]byte, error) {
if d.cover != nil {
return d.cover, nil
}
imgURL := d.meta.GetAlbumImageURL()
if d.meta != nil && !strings.HasPrefix(imgURL, "http") {
return nil, nil // no cover image
}
// fetch cover image
req, err := http.NewRequestWithContext(ctx, http.MethodGet, imgURL, nil)
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, fmt.Errorf("download image failed: %w", err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return nil, fmt.Errorf("download image failed: unexpected http status %s", resp.Status)
}
data, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("download image failed: %w", err)
}
return data, nil
}
func (d *Decoder) GetMeta() common.Meta {
return d.meta
}
func init() {
// Netease Mp3/Flac
common.RegisterDecoder("ncm", false, NewDecoder)
}