goc_marek/presta_front
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

cookie_decrypt

Browse Source
This commit is contained in:
Marek Goc
2025-11-13 10:45:26 +01:00
commit 76b66227e4
6 changed files with 434 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cookie/cookie.go
+213
View File
@@ -0,0 +1,213 @@
package cookie
import (
"crypto/aes"
"crypto/cipher"
"crypto/hmac"
"crypto/rand"
"crypto/sha256"
"encoding/hex"
"errors"
"strings"
)
type DecryptEncrypt struct {
_new_cookie_key_ string
}
func New() *DecryptEncrypt {
return &DecryptEncrypt{
_new_cookie_key_: "def000008bf3d70e7012b7493c382d561e193218d0c74ab162fb0ea8029ce20e926531b4bcf0aaec9381152e6c161f198e06918b2d1aad67cc7cf40819a51ee328c63830",
}
}
const (
CurrentVersion = "\xDE\xF5\x02\x00"
KeyCurrentVersion = "\xDE\xF0\x00\x00"
SaltSize = 32
IVSize = 16
MacSize = 32
MinCiphertextSize = 84
KeyByteSize = 32
ChecksumSize = 32
HeaderSize = 4
AuthInfo = "DefusePHP|V2|KeyForAuthentication"
EncInfo = "DefusePHP|V2|KeyForEncryption"
PBKDF2Iterations = 100000
)
// === DECRYPT ===
func (d *DecryptEncrypt) DecryptInternal(ciphertextHex string, kp *KeyOrPassword, rawBinary bool) ([]byte, error) {
var ct []byte
var err error
if !rawBinary {
ct, err = d.hexToBin(ciphertextHex)
if err != nil {
return nil, errors.New("invalid hex")
}
} else {
ct = []byte(ciphertextHex)
}
if len(ct) < MinCiphertextSize {
return nil, errors.New("ciphertext too short")
}
// Extract parts
header := ct[:HeaderSize]
if string(header) != CurrentVersion {
return nil, errors.New("bad version")
}
salt := ct[HeaderSize : HeaderSize+SaltSize]
iv := ct[HeaderSize+SaltSize : HeaderSize+SaltSize+IVSize]
hmacStart := len(ct) - MacSize
// expectedHMAC := ct[hmacStart:]
encStart := HeaderSize + SaltSize + IVSize
encrypted := ct[encStart:hmacStart]
// Derive keys
keys, err := kp.DeriveKeys(salt)
if err != nil {
return nil, err
}
// === HMAC: salt || iv || encrypted ===
// message := append(append(salt, iv...), encrypted...)
// if !verifyHMAC(expectedHMAC, message, keys.akey) {
// return nil, errors.New("integrity check failed")
// }
// Decrypt
return d.aesCTRDecrypt(encrypted, keys.ekey, iv)
}
func (d *DecryptEncrypt) aesCTRDecrypt(ciphertext, key, iv []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
plaintext := make([]byte, len(ciphertext))
stream := cipher.NewCTR(block, iv)
stream.XORKeyStream(plaintext, ciphertext)
return plaintext, nil
}
// === ENCRYPT ===
func (d *DecryptEncrypt) EncryptInternal(plaintext, domain string) (string, error) {
key, err := d.LoadKeyFromASCII()
if err != nil {
return "", err
}
kp := &KeyOrPassword{SecretType: 1, Key: key}
salt := make([]byte, SaltSize)
if _, err := rand.Read(salt); err != nil {
return "", err
}
iv := make([]byte, IVSize)
if _, err := rand.Read(iv); err != nil {
return "", err
}
keys, err := kp.DeriveKeys(salt)
if err != nil {
return "", err
}
encrypted, err := d.aesCTREncrypt([]byte(plaintext), keys.ekey, iv)
if err != nil {
return "", err
}
// HMAC over: salt || iv || ciphertext
message := append(append(salt, iv...), encrypted...)
hmacVal := hmac.New(sha256.New, keys.akey)
hmacVal.Write(message)
mac := hmacVal.Sum(nil)
// Assemble: header || salt || iv || encrypted || mac
result := append([]byte(CurrentVersion), salt...)
result = append(result, iv...)
result = append(result, encrypted...)
result = append(result, mac...)
return hex.EncodeToString(result), nil
}
func (d DecryptEncrypt) aesCTREncrypt(plaintext, key, iv []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
ciphertext := make([]byte, len(plaintext))
stream := cipher.NewCTR(block, iv)
stream.XORKeyStream(ciphertext, plaintext)
return ciphertext, nil
}
func (d *DecryptEncrypt) LoadKeyFromASCII() (*Key, error) {
b, err := d.loadBytesFromChecksummedASCII(KeyCurrentVersion)
if err != nil {
return nil, err
}
if len(b) != KeyByteSize {
return nil, errors.New("bad key length")
}
return &Key{bytes: b}, nil
}
func (d *DecryptEncrypt) loadBytesFromChecksummedASCII(expectedHeader string) ([]byte, error) {
data, err := d.hexToBin(d._new_cookie_key_)
if err != nil {
return nil, err
}
if len(data) < HeaderSize+ChecksumSize {
return nil, errors.New("data too short")
}
if string(data[:HeaderSize]) != expectedHeader {
return nil, errors.New("invalid header")
}
payloadLen := len(data) - ChecksumSize
checked := data[:payloadLen]
sum := sha256.Sum256(checked)
if !hmac.Equal(sum[:], data[payloadLen:]) {
return nil, errors.New("checksum mismatch")
}
return data[HeaderSize:payloadLen], nil
}
// func verifyHMAC(expected, msg, key []byte) bool {
// mac := hmac.New(sha256.New, key)
// mac.Write(msg)
// return hmac.Equal(mac.Sum(nil), expected)
// }
// === hexToBin ===
func (d *DecryptEncrypt) hexToBin(s string) ([]byte, error) {
s = strings.ToLower(s)
if len(s)%2 != 0 {
return nil, errors.New("odd length hex")
}
b := make([]byte, len(s)/2)
for i := 0; i < len(s); i += 2 {
hi := d.hexChar(s[i])
lo := d.hexChar(s[i+1])
if hi < 0 || lo < 0 {
return nil, errors.New("invalid hex char")
}
b[i/2] = byte(hi<<4 | lo)
}
return b, nil
}
func (d *DecryptEncrypt) hexChar(c byte) int {
switch {
case '0' <= c && c <= '9':
return int(c - '0')
case 'a' <= c && c <= 'f':
return int(c-'a') + 10
default:
return -1
}
}
cookie/keyorpassword.go
+67
View File
@@ -0,0 +1,67 @@
package cookie
import (
"crypto/hmac"
"crypto/sha256"
"errors"
"hash"
)
type KeyOrPassword struct {
SecretType int
Key *Key
Password string
DerivedKeys *DerivedKeys
Akey []byte
Ekey []byte
}
type DerivedKeys struct{ akey, ekey []byte }
type Key struct{ bytes []byte }
func (k *Key) GetRawBytes() []byte { return k.bytes }
func (kp *KeyOrPassword) DeriveKeys(salt []byte) (*DerivedKeys, error) {
if len(salt) != SaltSize {
return nil, errors.New("bad salt")
}
if kp.SecretType == 1 {
akey := kp.hkdf(sha256.New, kp.Key.GetRawBytes(), KeyByteSize, AuthInfo, salt)
ekey := kp.hkdf(sha256.New, kp.Key.GetRawBytes(), KeyByteSize, EncInfo, salt)
return &DerivedKeys{akey: akey, ekey: ekey}, nil
}
return nil, errors.New("unsupported")
}
// === HKDF ===
func (kp *KeyOrPassword) hkdf(hashFunc func() hash.Hash, ikm []byte, length int, info string, salt []byte) []byte {
digestLen := hashFunc().Size()
if salt == nil {
salt = make([]byte, digestLen)
}
// Extract
prkMac := hmac.New(hashFunc, salt)
prkMac.Write(ikm)
prk := prkMac.Sum(nil)
// Expand
var okm []byte
prev := []byte{}
counter := byte(1)
for len(okm) < length {
h := hmac.New(hashFunc, prk)
h.Write(prev)
h.Write([]byte(info))
h.Write([]byte{counter})
step := h.Sum(nil)
okm = append(okm, step...)
prev = step
counter++
}
return okm[:length]
}
cookie/tools.go
+3
View File
@@ -0,0 +1,3 @@
package cookie
// === Key Loading ===
go.mod
+5
View File
@@ -0,0 +1,5 @@
module presta
go 1.25.1
require github.com/golang-jwt/jwt/v5 v5.3.0
go.sum
+2
View File
@@ -0,0 +1,2 @@
github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
main.go
+144
View File
@@ -0,0 +1,144 @@
package main
import (
"crypto/md5"
"encoding/hex"
"fmt"
"log"
"presta/cookie"
"strings"
)
// === PrestaShop Constants ===
const (
_PS_VERSION_ = "1.7.6.3"
// _NEW_COOKIE_KEY_ = "def000008bf3d70e7012b7493c382d561e193218d0c74ab162fb0ea8029ce20e926531b4bcf0aaec9381152e6c161f198e06918b2d1aad67cc7cf40819a51ee328c63830"
__COOKIE__ = "def5020099dce5cd9ecf197adb5532a74e3db2ed9cba3d59b98f365353099b710bd562efa48b6bad1ad0a12b2ee54de0fbfcc6baa0545a8234141b03bfc1fbbbb9061af5011764b9c4dfd9c0ddcad767a453e0cc24d6b4a7c524e6c49aabd66ecc390e1a964b6e81a051b171051c829542facbb36cf64fcfebf069906dcc95476578be3fe59aaae466cf70bd9c877d301d908ec3aa4f55366567f460dfefac1684ce381293e8d4138382a42716d6aaecdcc7"
__EXPECTED_RESULT__ = "date_add|2025-11-02 12:26:58¤id_lang|2¤id_currency|1¤id_guest|23381445¤id_connections|2245874¤checksum|1154356442"
)
// === Crypto Constants ===
// === CookTest ===
type CookTest struct {
content map[string]string
name string
domain string
path string
standalone bool
expire int64
}
func main() {
// === DECRYPTION TEST ===
ct, err := NewCookTest("", "", nil, nil, false, false)
if err != nil {
log.Fatal("Decrypt failed:", err)
}
dct := cookie.New()
if err != nil {
log.Fatal("New DecryptEncrypt failed:", err)
}
fmt.Println("<pre>")
for k, v := range ct.content {
fmt.Printf("%s: %s\n", k, v)
}
fmt.Printf("Match expected: %v\n", ct.String() == __EXPECTED_RESULT__)
fmt.Println("</pre>")
// === ENCRYPTION TEST ===
newData := "date_add|2025-11-03 10:00:00¤id_lang|1¤id_currency|2¤id_guest|999999¤id_connections|888888¤checksum|1234567890"
encryptedHex, err := dct.EncryptInternal(newData, ct.domain)
if err != nil {
log.Fatal("Encrypt failed:", err)
}
fmt.Printf("Encrypted cookie: %s\n", encryptedHex)
// Optional: Try decrypting it back
// ct2, _ := NewCookTestFromCookie(encryptedHex, ct.domain)
// fmt.Println("Re-decrypted:", ct2.String())
}
func NewCookTest(name, path string, expire *int64, sharedURLs []string, standalone, secure bool) (*CookTest, error) {
ct := &CookTest{
content: make(map[string]string),
standalone: standalone,
}
dct := cookie.New()
if expire == nil {
ct.expire = 1728000
} else {
ct.expire = *expire
}
path = strings.Trim(path, "/\\")
if !standalone && path != "" {
path = "/" + path
}
if path != "" && path[0] != '/' {
path = "/" + path
}
ct.path = path
ct.domain = ct.getDomain(sharedURLs)
versionPart := ""
if !standalone {
versionPart = _PS_VERSION_
}
ct.name = "PrestaShop-" + md5String(versionPart+name+ct.domain)
fmt.Printf("name: %v\n", ct.name)
key, err := dct.LoadKeyFromASCII()
if err != nil {
return nil, err
}
kp := &cookie.KeyOrPassword{SecretType: 1, Key: key}
plaintext, err := dct.DecryptInternal(__COOKIE__, kp, false)
if err != nil {
return nil, fmt.Errorf("decrypt failed: %w", err)
}
ct.parseContent(string(plaintext))
return ct, nil
}
func (ct *CookTest) parseContent(data string) {
pairs := strings.Split(data, "¤")
for _, p := range pairs {
if strings.Contains(p, "|") {
parts := strings.SplitN(p, "|", 2)
if len(parts) == 2 {
ct.content[parts[0]] = parts[1]
}
}
}
}
func (ct *CookTest) String() string {
order := []string{"date_add", "id_lang", "id_currency", "id_guest", "id_connections", "checksum"}
var parts []string
for _, k := range order {
if v, ok := ct.content[k]; ok {
parts = append(parts, k+"|"+v)
}
}
return strings.Join(parts, "¤")
}
func (ct *CookTest) getDomain(sharedURLs []string) string {
return "localhost"
}
// === MD5 ===
func md5String(s string) string {
sum := md5.Sum([]byte(s))
return hex.EncodeToString(sum[:])
}