mirror of
https://git.sr.ht/~joren/streamrip-go
synced 2026-06-17 15:05:39 +02:00
implement native Deezer download/decrypt pipeline
Replace Deezer yt-dlp usage with native ARL session + media.get_url resolution, add BF_CBC_STRIPE decryption in downloader, and wire cipher-aware Deezer downloads through the main rip pipeline. Includes validation hardening and metadata/source-id improvements used by tagging flows.
This commit is contained in:
@@ -8,7 +8,6 @@ import (
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os/exec"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
@@ -19,17 +18,24 @@ import (
|
||||
"streamrip-go/internal/ratelimit"
|
||||
)
|
||||
|
||||
var baseURL = "https://api.deezer.com"
|
||||
|
||||
type commandRunner func(ctx context.Context, name string, args ...string) ([]byte, error)
|
||||
var (
|
||||
baseURL = "https://api.deezer.com"
|
||||
webGWLight = "https://www.deezer.com/ajax/gw-light.php"
|
||||
mediaURL = "https://media.deezer.com/v1/get_url"
|
||||
deezerUA = "Deezer/9.0.11.4 (Android; 14; Mobile; us) Xiaomi Redmi Note 7"
|
||||
)
|
||||
|
||||
type Client struct {
|
||||
cfg *config.Config
|
||||
http *http.Client
|
||||
limiter *ratelimit.Limiter
|
||||
loggedIn bool
|
||||
bin string
|
||||
run commandRunner
|
||||
sid string
|
||||
arl string
|
||||
jwt string
|
||||
refresh string
|
||||
license string
|
||||
userID string
|
||||
}
|
||||
|
||||
func New(cfg *config.Config) *Client {
|
||||
@@ -37,8 +43,7 @@ func New(cfg *config.Config) *Client {
|
||||
cfg: cfg,
|
||||
http: netutil.NewHTTPClient(30*time.Second, cfg.Session.Downloads.VerifySSL),
|
||||
limiter: ratelimit.New(cfg.Session.Downloads.RequestsPerMinute),
|
||||
bin: "yt-dlp",
|
||||
run: runCommand,
|
||||
arl: strings.TrimSpace(cfg.Session.Deezer.ARL),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -46,7 +51,13 @@ func (c *Client) Source() string {
|
||||
return "deezer"
|
||||
}
|
||||
|
||||
func (c *Client) Login(context.Context) error {
|
||||
func (c *Client) Login(ctx context.Context) error {
|
||||
c.arl = strings.TrimSpace(c.cfg.Session.Deezer.ARL)
|
||||
if c.arl != "" {
|
||||
if err := c.refreshSessionFromARL(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
c.loggedIn = true
|
||||
return nil
|
||||
}
|
||||
@@ -165,158 +176,38 @@ func (c *Client) GetMetadata(ctx context.Context, item, mediaType string) (map[s
|
||||
}
|
||||
|
||||
func (c *Client) GetDownloadable(ctx context.Context, item string, _ int) (*provider.Downloadable, error) {
|
||||
if strings.TrimSpace(c.arl) == "" {
|
||||
return nil, errors.New("deezer native download requires deezer.arl in config")
|
||||
}
|
||||
if strings.TrimSpace(c.license) == "" {
|
||||
if err := c.refreshSessionFromARL(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
meta, err := c.GetMetadata(ctx, item, "track")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if c.shouldTryYtDlp() {
|
||||
d, dlErr := c.getDownloadableViaYtDlp(ctx, item, meta)
|
||||
if dlErr == nil {
|
||||
return d, nil
|
||||
}
|
||||
if !c.cfg.Session.Deezer.LowerQualityIfNotAvailable {
|
||||
return nil, fmt.Errorf("deezer full-quality mode failed and fallback is disabled: %w", dlErr)
|
||||
trackToken := strings.TrimSpace(stringFromAny(meta["track_token"]))
|
||||
if trackToken == "" {
|
||||
trackToken, err = c.getTrackToken(ctx, item)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
preview := strings.TrimSpace(stringFromAny(meta["preview"]))
|
||||
if preview == "" {
|
||||
return nil, errors.New("deezer track missing preview url")
|
||||
}
|
||||
return &provider.Downloadable{URL: preview, Extension: "mp3", Source: "deezer"}, nil
|
||||
}
|
||||
|
||||
func (c *Client) shouldTryYtDlp() bool {
|
||||
if c.cfg == nil {
|
||||
return false
|
||||
}
|
||||
if c.cfg.Session.Deezer.UseDeezloader {
|
||||
return true
|
||||
}
|
||||
return strings.TrimSpace(c.cfg.Session.Deezer.ARL) != ""
|
||||
}
|
||||
|
||||
func (c *Client) getDownloadableViaYtDlp(ctx context.Context, trackID string, meta map[string]any) (*provider.Downloadable, error) {
|
||||
if _, err := exec.LookPath(c.bin); err != nil {
|
||||
return nil, fmt.Errorf("yt-dlp not found for deezer full-quality mode: %w", err)
|
||||
}
|
||||
|
||||
target := strings.TrimSpace(stringFromAny(meta["link"]))
|
||||
if target == "" {
|
||||
target = "https://www.deezer.com/track/" + trackID
|
||||
}
|
||||
args := []string{"-J", "--no-playlist", "--skip-download", "--no-warnings"}
|
||||
if arl := strings.TrimSpace(c.cfg.Session.Deezer.ARL); arl != "" {
|
||||
args = append(args, "--add-header", "Cookie: arl="+arl)
|
||||
}
|
||||
args = append(args, target)
|
||||
b, err := c.run(ctx, c.bin, args...)
|
||||
media, err := c.getMediaURL(ctx, trackToken, c.cfg.Session.Deezer.Quality, c.cfg.Session.Deezer.LowerQualityIfNotAvailable)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
info := map[string]any{}
|
||||
if err = json.Unmarshal(b, &info); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
f := selectDeezerFormat(info, c.cfg.Session.Deezer.Quality)
|
||||
if f.url == "" {
|
||||
return nil, errors.New("yt-dlp output missing downloadable format url")
|
||||
}
|
||||
ext := f.ext
|
||||
ext := extensionForFormat(media.Format)
|
||||
if ext == "" {
|
||||
ext = "mp3"
|
||||
}
|
||||
return &provider.Downloadable{URL: f.url, Extension: ext, Source: "deezer"}, nil
|
||||
}
|
||||
|
||||
type deezerFormat struct {
|
||||
url string
|
||||
ext string
|
||||
abr int
|
||||
}
|
||||
|
||||
func selectDeezerFormat(info map[string]any, quality int) deezerFormat {
|
||||
formats, _ := info["formats"].([]any)
|
||||
selected := deezerFormat{}
|
||||
|
||||
pick := func(candidate deezerFormat, better func(cur, next deezerFormat) bool) {
|
||||
if candidate.url == "" {
|
||||
return
|
||||
}
|
||||
if selected.url == "" || better(selected, candidate) {
|
||||
selected = candidate
|
||||
}
|
||||
trackID := strings.TrimSpace(stringFromAny(meta["id"]))
|
||||
if trackID == "" {
|
||||
trackID = strings.TrimSpace(item)
|
||||
}
|
||||
|
||||
for _, raw := range formats {
|
||||
m, ok := raw.(map[string]any)
|
||||
if !ok {
|
||||
continue
|
||||
}
|
||||
if strings.TrimSpace(stringFromAny(m["vcodec"])) != "none" {
|
||||
continue
|
||||
}
|
||||
cand := deezerFormat{
|
||||
url: strings.TrimSpace(stringFromAny(m["url"])),
|
||||
ext: strings.TrimSpace(stringFromAny(m["ext"])),
|
||||
abr: intFromAny(m["abr"]),
|
||||
}
|
||||
if quality >= 2 {
|
||||
pick(cand, func(cur, next deezerFormat) bool {
|
||||
curFlac := strings.EqualFold(cur.ext, "flac")
|
||||
nextFlac := strings.EqualFold(next.ext, "flac")
|
||||
if curFlac != nextFlac {
|
||||
return nextFlac
|
||||
}
|
||||
return next.abr > cur.abr
|
||||
})
|
||||
continue
|
||||
}
|
||||
if quality == 1 {
|
||||
pick(cand, func(cur, next deezerFormat) bool {
|
||||
curScore := abrScore(cur.abr, 320)
|
||||
nextScore := abrScore(next.abr, 320)
|
||||
if curScore == nextScore {
|
||||
return next.abr > cur.abr
|
||||
}
|
||||
return nextScore > curScore
|
||||
})
|
||||
continue
|
||||
}
|
||||
pick(cand, func(cur, next deezerFormat) bool {
|
||||
curScore := abrScore(cur.abr, 128)
|
||||
nextScore := abrScore(next.abr, 128)
|
||||
if curScore == nextScore {
|
||||
if cur.abr == 0 {
|
||||
return next.abr > 0
|
||||
}
|
||||
if next.abr == 0 {
|
||||
return false
|
||||
}
|
||||
return next.abr < cur.abr
|
||||
}
|
||||
return nextScore > curScore
|
||||
})
|
||||
}
|
||||
|
||||
if selected.url != "" {
|
||||
return selected
|
||||
}
|
||||
|
||||
rootURL := strings.TrimSpace(stringFromAny(info["url"]))
|
||||
if rootURL == "" {
|
||||
return deezerFormat{}
|
||||
}
|
||||
return deezerFormat{url: rootURL, ext: strings.TrimSpace(stringFromAny(info["ext"])), abr: intFromAny(info["abr"])}
|
||||
}
|
||||
|
||||
func abrScore(abr int, target int) int {
|
||||
if abr <= 0 {
|
||||
return -1
|
||||
}
|
||||
if abr > target {
|
||||
return target - (abr-target)*2
|
||||
}
|
||||
return abr
|
||||
return &provider.Downloadable{URL: media.URL, Extension: ext, Source: "deezer", Cipher: media.Cipher, TrackID: trackID}, nil
|
||||
}
|
||||
|
||||
func (c *Client) apiGet(ctx context.Context, path string, params url.Values) (map[string]any, error) {
|
||||
@@ -365,6 +256,227 @@ func (c *Client) apiGet(ctx context.Context, path string, params url.Values) (ma
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *Client) refreshSessionFromARL(ctx context.Context) error {
|
||||
if strings.TrimSpace(c.arl) == "" {
|
||||
return errors.New("missing deezer arl")
|
||||
}
|
||||
if err := c.limiter.Wait(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
params := url.Values{}
|
||||
params.Set("method", "deezer.getUserData")
|
||||
params.Set("input", "3")
|
||||
params.Set("api_version", "1.0")
|
||||
params.Set("api_token", "")
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, webGWLight+"?"+params.Encode(), nil)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
req.Header.Set("User-Agent", deezerUA)
|
||||
req.Header.Set("Accept", "application/json")
|
||||
req.Header.Set("Cookie", "arl="+strings.TrimSpace(c.arl))
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
raw, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
return fmt.Errorf("deezer getUserData failed: status=%d body=%s", resp.StatusCode, string(raw))
|
||||
}
|
||||
out := map[string]any{}
|
||||
if err = json.Unmarshal(raw, &out); err != nil {
|
||||
return err
|
||||
}
|
||||
if errObj, ok := out["error"].(map[string]any); ok && len(errObj) > 0 {
|
||||
return fmt.Errorf("deezer getUserData error: %s", stringFromAny(errObj["message"]))
|
||||
}
|
||||
results, _ := out["results"].(map[string]any)
|
||||
if len(results) == 0 {
|
||||
return errors.New("deezer getUserData returned empty results")
|
||||
}
|
||||
c.license = findStringByKey(results, "license_token")
|
||||
c.userID = findStringByKey(results, "USER_ID")
|
||||
if c.license == "" {
|
||||
return errors.New("deezer getUserData missing license_token")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Client) getTrackToken(ctx context.Context, trackID string) (string, error) {
|
||||
resp, err := c.apiGet(ctx, "/track/"+url.PathEscape(strings.TrimSpace(trackID)), nil)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
token := strings.TrimSpace(stringFromAny(resp["track_token"]))
|
||||
if token == "" {
|
||||
return "", errors.New("deezer track metadata missing track_token")
|
||||
}
|
||||
return token, nil
|
||||
}
|
||||
|
||||
type mediaResult struct {
|
||||
URL string
|
||||
Format string
|
||||
Cipher string
|
||||
}
|
||||
|
||||
func (c *Client) getMediaURL(ctx context.Context, trackToken string, quality int, allowFallback bool) (*mediaResult, error) {
|
||||
requestedFormats := buildFormatPriority(quality, allowFallback)
|
||||
var lastErr error
|
||||
for _, format := range requestedFormats {
|
||||
result, err := c.getMediaURLForFormat(ctx, trackToken, format)
|
||||
if err == nil {
|
||||
return result, nil
|
||||
}
|
||||
lastErr = err
|
||||
if !allowFallback {
|
||||
break
|
||||
}
|
||||
}
|
||||
if lastErr != nil {
|
||||
return nil, lastErr
|
||||
}
|
||||
return nil, errors.New("deezer media response contains no playable variants")
|
||||
}
|
||||
|
||||
func (c *Client) getMediaURLForFormat(ctx context.Context, trackToken, format string) (*mediaResult, error) {
|
||||
if strings.TrimSpace(c.license) == "" {
|
||||
return nil, errors.New("missing deezer license token")
|
||||
}
|
||||
if err := c.limiter.Wait(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
reqBody := map[string]any{
|
||||
"license_token": c.license,
|
||||
"track_tokens": []string{trackToken},
|
||||
"media": []map[string]any{{
|
||||
"type": "FULL",
|
||||
"formats": []map[string]string{{"cipher": "BF_CBC_STRIPE", "format": format}, {"cipher": "NONE", "format": format}},
|
||||
}},
|
||||
}
|
||||
b, err := json.Marshal(reqBody)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, mediaURL, strings.NewReader(string(b)))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req.Header.Set("User-Agent", deezerUA)
|
||||
req.Header.Set("Accept", "*/*")
|
||||
req.Header.Set("Content-Type", "text/plain; charset=UTF-8")
|
||||
|
||||
resp, err := c.http.Do(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer func() { _ = resp.Body.Close() }()
|
||||
raw, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
||||
return nil, fmt.Errorf("deezer media get_url failed: status=%d body=%s", resp.StatusCode, string(raw))
|
||||
}
|
||||
var parsed struct {
|
||||
Data []struct {
|
||||
Errors []struct {
|
||||
Code int `json:"code"`
|
||||
Message string `json:"message"`
|
||||
} `json:"errors"`
|
||||
Media []struct {
|
||||
Cipher struct {
|
||||
Type string `json:"type"`
|
||||
} `json:"cipher"`
|
||||
Format string `json:"format"`
|
||||
Sources []struct {
|
||||
URL string `json:"url"`
|
||||
} `json:"sources"`
|
||||
} `json:"media"`
|
||||
} `json:"data"`
|
||||
}
|
||||
if err = json.Unmarshal(raw, &parsed); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(parsed.Data) == 0 {
|
||||
return nil, errors.New("deezer media response contains no data")
|
||||
}
|
||||
if len(parsed.Data[0].Errors) > 0 {
|
||||
e := parsed.Data[0].Errors[0]
|
||||
if strings.Contains(strings.ToLower(e.Message), "drm") {
|
||||
return nil, errors.New("deezer media is DRM protected for this format/account")
|
||||
}
|
||||
return nil, fmt.Errorf("deezer media error %d: %s", e.Code, e.Message)
|
||||
}
|
||||
for _, m := range parsed.Data[0].Media {
|
||||
if len(m.Sources) == 0 || strings.TrimSpace(m.Sources[0].URL) == "" {
|
||||
continue
|
||||
}
|
||||
return &mediaResult{URL: m.Sources[0].URL, Format: m.Format, Cipher: m.Cipher.Type}, nil
|
||||
}
|
||||
return nil, errors.New("deezer media response contains no sources")
|
||||
}
|
||||
|
||||
func buildFormatPriority(quality int, allowFallback bool) []string {
|
||||
want := "FLAC"
|
||||
if quality <= 0 {
|
||||
want = "MP3_128"
|
||||
} else if quality == 1 {
|
||||
want = "MP3_320"
|
||||
}
|
||||
priority := []string{want}
|
||||
if allowFallback {
|
||||
for _, f := range []string{"FLAC", "MP3_320", "MP3_128"} {
|
||||
if f != want {
|
||||
priority = append(priority, f)
|
||||
}
|
||||
}
|
||||
}
|
||||
return priority
|
||||
}
|
||||
|
||||
func extensionForFormat(format string) string {
|
||||
switch strings.ToUpper(strings.TrimSpace(format)) {
|
||||
case "FLAC":
|
||||
return "flac"
|
||||
case "MP3_320", "MP3_128", "MP3_64", "MP3_MISC":
|
||||
return "mp3"
|
||||
default:
|
||||
return "mp3"
|
||||
}
|
||||
}
|
||||
|
||||
func findStringByKey(v any, wantedKey string) string {
|
||||
w := strings.ToLower(strings.TrimSpace(wantedKey))
|
||||
switch x := v.(type) {
|
||||
case map[string]any:
|
||||
for k, value := range x {
|
||||
if strings.ToLower(k) == w {
|
||||
if s := stringFromAny(value); strings.TrimSpace(s) != "" {
|
||||
return s
|
||||
}
|
||||
}
|
||||
if nested := findStringByKey(value, wantedKey); nested != "" {
|
||||
return nested
|
||||
}
|
||||
}
|
||||
case []any:
|
||||
for _, item := range x {
|
||||
if nested := findStringByKey(item, wantedKey); nested != "" {
|
||||
return nested
|
||||
}
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func enrichTrack(track map[string]any) {
|
||||
if artist, ok := track["artist"].(map[string]any); ok {
|
||||
track["performer"] = map[string]any{"name": stringFromAny(artist["name"]), "id": stringFromAny(artist["id"])}
|
||||
@@ -452,12 +564,3 @@ func boolFromAny(v any) bool {
|
||||
b, ok := v.(bool)
|
||||
return ok && b
|
||||
}
|
||||
|
||||
func runCommand(ctx context.Context, name string, args ...string) ([]byte, error) {
|
||||
cmd := exec.CommandContext(ctx, name, args...)
|
||||
b, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("command %s failed: %w: %s", name, err, string(b))
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user