init: dec-music 项目初始化
This commit is contained in:
@@ -0,0 +1,33 @@
|
||||
package crypto
|
||||
|
||||
import "crypto/aes"
|
||||
|
||||
// PKCS7UnPadding removes PKCS#7 padding.
|
||||
func PKCS7UnPadding(encrypt []byte) []byte {
|
||||
length := len(encrypt)
|
||||
if length == 0 {
|
||||
return encrypt
|
||||
}
|
||||
unPadding := int(encrypt[length-1])
|
||||
if unPadding <= 0 || unPadding > length {
|
||||
return encrypt
|
||||
}
|
||||
return encrypt[:length-unPadding]
|
||||
}
|
||||
|
||||
// DecryptAES128ECB decrypts data with AES-128 ECB (block size 16).
|
||||
func DecryptAES128ECB(data, key []byte) []byte {
|
||||
cipher, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
decrypted := make([]byte, len(data))
|
||||
size := aes.BlockSize
|
||||
for bs, be := 0, size; bs < len(data); bs, be = bs+size, be+size {
|
||||
if be > len(data) {
|
||||
break
|
||||
}
|
||||
cipher.Decrypt(decrypted[bs:be], data[bs:be])
|
||||
}
|
||||
return decrypted
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package fileutil
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var (
|
||||
standardMediaExts = map[string]struct{}{
|
||||
".mp3": {}, ".flac": {}, ".wav": {}, ".m4a": {},
|
||||
".ogg": {}, ".opus": {}, ".aac": {}, ".wma": {},
|
||||
".ape": {}, ".alac": {}, ".dsf": {}, ".dff": {},
|
||||
}
|
||||
encryptedMediaExts = map[string]struct{}{
|
||||
".kgma": {}, ".kgm": {},
|
||||
".ncm": {},
|
||||
".qmc": {}, ".qmc0": {}, ".qmc3": {}, ".qmcflac": {}, ".qmcogg": {},
|
||||
".mgg": {}, ".mflac": {},
|
||||
".tm": {}, ".tkm": {},
|
||||
".xiami": {}, ".xm": {},
|
||||
".ximalaya": {}, ".xmly": {},
|
||||
".x2m": {}, ".x3m": {},
|
||||
".kwm": {},
|
||||
}
|
||||
videoMediaExts = map[string]struct{}{
|
||||
".mp4": {}, ".mkv": {}, ".avi": {}, ".mov": {}, ".flv": {},
|
||||
}
|
||||
)
|
||||
|
||||
// IsMediaFile reports whether the file name looks like a media file this tool handles.
|
||||
func IsMediaFile(fileName string) bool {
|
||||
ext := strings.ToLower(filepath.Ext(fileName))
|
||||
if _, ok := standardMediaExts[ext]; ok {
|
||||
return true
|
||||
}
|
||||
if _, ok := encryptedMediaExts[ext]; ok {
|
||||
return true
|
||||
}
|
||||
if _, ok := videoMediaExts[ext]; ok {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// FileExist reports whether path exists.
|
||||
func FileExist(path string) bool {
|
||||
_, err := os.Stat(path)
|
||||
return err == nil
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
package sniff
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"slices"
|
||||
)
|
||||
|
||||
type Sniffer interface {
|
||||
Sniff(header []byte) bool
|
||||
}
|
||||
|
||||
var audioExtensions = map[string]Sniffer{
|
||||
// ref: https://mimesniff.spec.whatwg.org
|
||||
".mp3": prefixSniffer("ID3"), // todo: check mp3 without ID3v2 tag
|
||||
".ogg": prefixSniffer("OggS"),
|
||||
".wav": prefixSniffer("RIFF"),
|
||||
|
||||
// ref: https://www.loc.gov/preservation/digital/formats/fdd/fdd000027.shtml
|
||||
".wma": prefixSniffer{
|
||||
0x30, 0x26, 0xb2, 0x75, 0x8e, 0x66, 0xcf, 0x11,
|
||||
0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62, 0xce, 0x6c,
|
||||
},
|
||||
|
||||
// ref: https://www.garykessler.net/library/file_sigs.html
|
||||
".m4a": m4aSniffer{}, // MPEG-4 container, Apple Lossless Audio Codec
|
||||
".mp4": &mpeg4Sniffer{}, // MPEG-4 container, other fallback
|
||||
|
||||
".flac": prefixSniffer("fLaC"), // ref: https://xiph.org/flac/format.html
|
||||
".dff": prefixSniffer("FRM8"), // DSDIFF, ref: https://www.sonicstudio.com/pdf/dsd/DSDIFF_1.5_Spec.pdf
|
||||
|
||||
}
|
||||
|
||||
// AudioExtension sniffs the known audio types, and returns the file extension.
|
||||
// header is recommended to at least 16 bytes.
|
||||
func AudioExtension(header []byte) (string, bool) {
|
||||
for ext, sniffer := range audioExtensions {
|
||||
if sniffer.Sniff(header) {
|
||||
return ext, true
|
||||
}
|
||||
}
|
||||
return "", false
|
||||
}
|
||||
|
||||
// AudioExtensionWithFallback is equivalent to AudioExtension, but returns fallback
|
||||
// most likely to use .mp3 as fallback, because mp3 files may not have ID3v2 tag.
|
||||
func AudioExtensionWithFallback(header []byte, fallback string) string {
|
||||
ext, ok := AudioExtension(header)
|
||||
if !ok {
|
||||
return fallback
|
||||
}
|
||||
return ext
|
||||
}
|
||||
|
||||
type prefixSniffer []byte
|
||||
|
||||
func (s prefixSniffer) Sniff(header []byte) bool {
|
||||
return bytes.HasPrefix(header, s)
|
||||
}
|
||||
|
||||
type m4aSniffer struct{}
|
||||
|
||||
func (m4aSniffer) Sniff(header []byte) bool {
|
||||
box := readMpeg4FtypBox(header)
|
||||
if box == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
return box.majorBrand == "M4A " || slices.Contains(box.compatibleBrands, "M4A ")
|
||||
}
|
||||
|
||||
type mpeg4Sniffer struct{}
|
||||
|
||||
func (s *mpeg4Sniffer) Sniff(header []byte) bool {
|
||||
return readMpeg4FtypBox(header) != nil
|
||||
}
|
||||
|
||||
type mpeg4FtpyBox struct {
|
||||
majorBrand string
|
||||
minorVersion uint32
|
||||
compatibleBrands []string
|
||||
}
|
||||
|
||||
func readMpeg4FtypBox(header []byte) *mpeg4FtpyBox {
|
||||
if (len(header) < 8) || !bytes.Equal([]byte("ftyp"), header[4:8]) {
|
||||
return nil // not a valid ftyp box
|
||||
}
|
||||
|
||||
size := binary.BigEndian.Uint32(header[0:4]) // size
|
||||
if size < 16 || size%4 != 0 {
|
||||
return nil // invalid ftyp box
|
||||
}
|
||||
|
||||
box := mpeg4FtpyBox{
|
||||
majorBrand: string(header[8:12]),
|
||||
minorVersion: binary.BigEndian.Uint32(header[12:16]),
|
||||
}
|
||||
|
||||
// compatible brands
|
||||
for i := 16; i < int(size) && i+4 < len(header); i += 4 {
|
||||
box.compatibleBrands = append(box.compatibleBrands, string(header[i:i+4]))
|
||||
}
|
||||
|
||||
return &box
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
// Copyright 2015 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package tea implements the TEA algorithm, as defined in Needham and
|
||||
// Wheeler's 1994 technical report, “TEA, a Tiny Encryption Algorithm”. See
|
||||
// http://www.cix.co.uk/~klockstone/tea.pdf for details.
|
||||
//
|
||||
// TEA is a legacy cipher and its short block size makes it vulnerable to
|
||||
// birthday bound attacks (see https://sweet32.info). It should only be used
|
||||
// where compatibility with legacy systems, not security, is the goal.
|
||||
//
|
||||
// Deprecated: any new system should use AES (from crypto/aes, if necessary in
|
||||
// an AEAD mode like crypto/cipher.NewGCM) or XChaCha20-Poly1305 (from
|
||||
// golang.org/x/crypto/chacha20poly1305).
|
||||
package tea
|
||||
|
||||
import (
|
||||
"crypto/cipher"
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
)
|
||||
|
||||
const (
|
||||
// BlockSize is the size of a TEA block, in bytes.
|
||||
BlockSize = 8
|
||||
|
||||
// KeySize is the size of a TEA key, in bytes.
|
||||
KeySize = 16
|
||||
|
||||
// delta is the TEA key schedule constant.
|
||||
delta = 0x9e3779b9
|
||||
|
||||
// numRounds is the standard number of rounds in TEA.
|
||||
numRounds = 64
|
||||
)
|
||||
|
||||
// tea is an instance of the TEA cipher with a particular key.
|
||||
type tea struct {
|
||||
key [16]byte
|
||||
rounds int
|
||||
}
|
||||
|
||||
// NewCipher returns an instance of the TEA cipher with the standard number of
|
||||
// rounds. The key argument must be 16 bytes long.
|
||||
func NewCipher(key []byte) (cipher.Block, error) {
|
||||
return NewCipherWithRounds(key, numRounds)
|
||||
}
|
||||
|
||||
// NewCipherWithRounds returns an instance of the TEA cipher with a given
|
||||
// number of rounds, which must be even. The key argument must be 16 bytes
|
||||
// long.
|
||||
func NewCipherWithRounds(key []byte, rounds int) (cipher.Block, error) {
|
||||
if len(key) != 16 {
|
||||
return nil, errors.New("tea: incorrect key size")
|
||||
}
|
||||
|
||||
if rounds&1 != 0 {
|
||||
return nil, errors.New("tea: odd number of rounds specified")
|
||||
}
|
||||
|
||||
c := &tea{
|
||||
rounds: rounds,
|
||||
}
|
||||
copy(c.key[:], key)
|
||||
|
||||
return c, nil
|
||||
}
|
||||
|
||||
// BlockSize returns the TEA block size, which is eight bytes. It is necessary
|
||||
// to satisfy the Block interface in the package "crypto/cipher".
|
||||
func (*tea) BlockSize() int {
|
||||
return BlockSize
|
||||
}
|
||||
|
||||
// Encrypt encrypts the 8 byte buffer src using the key in t and stores the
|
||||
// result in dst. Note that for amounts of data larger than a block, it is not
|
||||
// safe to just call Encrypt on successive blocks; instead, use an encryption
|
||||
// mode like CBC (see crypto/cipher/cbc.go).
|
||||
func (t *tea) Encrypt(dst, src []byte) {
|
||||
e := binary.BigEndian
|
||||
v0, v1 := e.Uint32(src), e.Uint32(src[4:])
|
||||
k0, k1, k2, k3 := e.Uint32(t.key[0:]), e.Uint32(t.key[4:]), e.Uint32(t.key[8:]), e.Uint32(t.key[12:])
|
||||
|
||||
sum := uint32(0)
|
||||
delta := uint32(delta)
|
||||
|
||||
for i := 0; i < t.rounds/2; i++ {
|
||||
sum += delta
|
||||
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1)
|
||||
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3)
|
||||
}
|
||||
|
||||
e.PutUint32(dst, v0)
|
||||
e.PutUint32(dst[4:], v1)
|
||||
}
|
||||
|
||||
// Decrypt decrypts the 8 byte buffer src using the key in t and stores the
|
||||
// result in dst.
|
||||
func (t *tea) Decrypt(dst, src []byte) {
|
||||
e := binary.BigEndian
|
||||
v0, v1 := e.Uint32(src), e.Uint32(src[4:])
|
||||
k0, k1, k2, k3 := e.Uint32(t.key[0:]), e.Uint32(t.key[4:]), e.Uint32(t.key[8:]), e.Uint32(t.key[12:])
|
||||
|
||||
delta := uint32(delta)
|
||||
sum := delta * uint32(t.rounds/2) // in general, sum = delta * n
|
||||
|
||||
for i := 0; i < t.rounds/2; i++ {
|
||||
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3)
|
||||
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1)
|
||||
sum -= delta
|
||||
}
|
||||
|
||||
e.PutUint32(dst, v0)
|
||||
e.PutUint32(dst[4:], v1)
|
||||
}
|
||||
Reference in New Issue
Block a user