İdda uğruna kafayı yemek. Üstatlar yardıma ihtiyacım var.

Üstatlarım ve saygıdeğer kardeşlerim. Elimde bir go binary dosya var.

Bir lisans kontrol mantığı var arkada ama bir türlü çözemiyorum kafayı yedirtti bana.

Öncelikle tahminime göre CBC gibi bir sistem var. Padding yapılmış ve muhtemelen Cipher'lenmiş.

Yani tahminime göre bu durumda bu şifreyi çözmek için KEY ve IV gerekli. Bunlar olmadan bu şifreyi nah çözerim gibime geldi.

Sonra reverse engineer yapayım dedim ama bu dosyayı tersine uyarlayamadım.

Şimdi bu binary haline gelmiş containerde çalışan binary dosyasını nasıl decomp yapıp kodlara bakabilirim yada nasıl bunu çözüp kaynak kodunu okuyabilirim.

Benim için çok önemli bir konu desteklerinizi bekliyorum.

Örnek Lisans --> gWU3XQRZTBt0wHZQUXuhVpCSbgl7SKv28z2_hUPIIOhoIiZW08sSseaIWuNotTCIrfNMBvyrTmqg0jvZTsdrA6GYqkd_BbJKDJp-EBR5fIy8tv7naGN0zZCr1ClfX6hi

Binary dosyası bu lisanstan yola çıkarak şu veriyi üretiyor (systemguid) --> 8b0a4d56-b90d-8492-b2fe-012f41cceac6
Birde tarih üretimi var (expiry) --> 27.10.2024

Ardından kontrol işlemini VM üzerinde çalışan sanal makinein üzerindeki systemguid ile eşit mi diye kontrol ederek devam ediyor. Eşitse ve lisans geçerli ise expiry date'ye kadar yazılım çalışıyor sonrasında ise duruyor.

Bunu çözmeme ve bana bu yolu öğretecek bir üstat varsa lütfen benimle pm üzerinden iletişime geçebilir mi ?

Kaynak kodlarına çok ihtiyacım var aşırı merak ediyorum.

Binary Link -->

Dümdüz makine kodu olduğu için VT eklemedim.

Attığım Go kodu ile kendi lisansını üretebilir veya mevcut lisans anahtarlarının şifresini çözebilirsin. Orijinal program üzerinde deneyemedim ancak çalışması lazım.

ivanpermyakov' Alıntı:

Attığım Go kodu ile kendi lisansını üretebilir veya mevcut lisans anahtarlarının şifresini çözebilirsin. Orijinal program üzerinde deneyemedim ancak çalışması lazım.

Kod:

Decrypted License: GUARDMONDEMO:::8b0a4d56-b90d-8492-b2fe-012f41cceac6:::27.10.2024
Generated License: Fz6jCJR7yjiWtbk-WDHPmAJpJQv3fwRejAuMTxA1KmxQ870joqhe7D5_nPk7_kCuYvEfGGB5l17ZW71xIqJykIK9n31HvrChiZ1VsDqIYGgjwm3kmkpwddcUV3j7-b1W

Kod:

package main

import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/base64"
    "fmt"
)

const PRODUCT_NAME string = "GUARDMONDEMO"
const MACHINE_GUID string = "8b0a4d56-b90d-8492-b2fe-012f41cceac6"
const EXPIRE_DATE string = "27.10.2024"

const LICENSE_DECRYPTION_KEY string = "3aI3TlHR8wNe43GE2ItDsE3h32W4s4s2"

func main() {
    fmt.Printf("Decrypted License: %s\n", decryptLicense("gWU3XQRZTBt0wHZQUXuhVpCSbgl7SKv28z2_hUPIIOhoIiZW08sSseaIWuNotTCIrfNMBvyrTmqg0jvZTsdrA6GYqkd_BbJKDJp-EBR5fIy8tv7naGN0zZCr1ClfX6hi"))
    fmt.Printf("Generated License: %s\n", generateLicense(PRODUCT_NAME, MACHINE_GUID, EXPIRE_DATE))
}

func generateLicense(product_name, machine_guid, expire_date string) string {
    return encryptLicense(fmt.Sprintf("%s:::%s:::%s", product_name, machine_guid, expire_date))
}

func encryptLicense(license string) string {
    result := []byte(license)
    result, _ = Pad(result, aes.BlockSize)

    block, _ := aes.NewCipher([]byte(LICENSE_DECRYPTION_KEY))
    iv := make([]byte, 16)
    rand.Read(iv)

    mode := cipher.NewCBCEncrypter(block, iv)
    mode.CryptBlocks(result, result)

    result = append(iv, result...)
    return base64.URLEncoding.EncodeToString(result)
}

func decryptLicense(license string) string {
    decode, _ := base64.URLEncoding.DecodeString(license)
    block, _ := aes.NewCipher([]byte(LICENSE_DECRYPTION_KEY))

    iv := decode[:aes.BlockSize]
    decode = decode[aes.BlockSize:]

    mode := cipher.NewCBCDecrypter(block, iv)
    mode.CryptBlocks(decode, decode)

    decode, _ = Unpad(decode, aes.BlockSize)
    return string(decode)
}

func Pad(data []byte, blockSize uint) ([]byte, error) {
    neededBytes := blockSize - (uint(len(data)) % blockSize)
    return append(data, bytes.Repeat([]byte{byte(neededBytes)}, int(neededBytes))...), nil
}

func Unpad(data []byte, blockSize uint) ([]byte, error) {
    if blockSize < 1 {
        return nil, fmt.Errorf("Block size looks wrong")
    }

    if uint(len(data))%blockSize != 0 {
        return nil, fmt.Errorf("Data isn't aligned to blockSize")
    }

    if len(data) == 0 {
        return nil, fmt.Errorf("Data is empty")
    }

    paddingLength := int(data[len(data)-1])
    for _, el := range data[len(data)-paddingLength:] {
        if el != byte(paddingLength) {
            return nil, fmt.Errorf("Padding had malformed entries. Have '%x', expected '%x'", paddingLength, el)
        }
    }

    return data[:len(data)-paddingLength], nil
}

Genişletmek için tıkla ...

Hocam nasıl çözdüğünüzü açıklama şansınız var mı bu binaryi nasıl source yaptınız bu bilgi çok değerli bir bilgi ve öğrenmek isterim açıkcası