mirror of
https://github.com/moonD4rk/HackBrowserData
synced 2025-04-01 22:48:13 +00:00
feat: Refactor crypto decryption functions for consistency and error handling (#302)
* feat: Refactor crypto decryption functions for consistency and error handling - Close #301 - Refactored and renamed decryption functions across multiple files for consistency - Updated cookie sorting method to sort in descending order - Added new encryption functions for AES in CBC and GCM modes and DES in CBC mode - Added error handling to decryption functions and created new error variables for invalid ciphertext length and decode failures - Test cases added for encryption and decryption functions - Removed unused code and imports. * chore: Add new words to .typos.toml dictionary - Add new terms to `.typos.toml` dictionary - Improve code formatting and readability - Refactor functions for better performance - Update comments and documentation - Resolve minor bugs and errors * refactor: Refactor crypto package for better structure and readability - Refactored and cleaned up crypto package code for better readability - Renamed `ToByteArray` method to `bytes` for consistency - Modified `DecryptWithDPAPI` method to use `outBlob.bytes()` for efficiency - Added comments and removed unused methods in `loginPBE` - Refactored `nssPBE` and `metaPBE` Decrypt methods to use `deriveKeyAndIV` helper method - Improved overall maintainability and organization of codebase * refactor: Refactor firefox password encryption and decryption. - Implement ASN1PBE interface with various PBE struct types and encryption/decryption methods - Fix naming and remove unused variables in browsingdata and crypto files - Add tests for ASN1PBE implementation using external assertion package - Refactor and improve error handling in firefox file functions related to master key retrieval - Add input validation and AES-GCM encryption function to crypto file
This commit is contained in:
ᴍᴏᴏɴD4ʀᴋ
parent
c150b22c1b
commit
591b97ce6d
@ -3,5 +3,7 @@
|
||||
Readed = "Readed"
|
||||
Sie = "Sie"
|
||||
OT = "OT"
|
||||
Encrypter = "Encrypter"
|
||||
Decrypter = "Decrypter"
|
||||
[files]
|
||||
extend-exclude = ["go.mod", "go.sum"]
|
||||
@ -33,7 +33,7 @@ func (c *Chromium) GetMasterKey() ([]byte, error) {
|
||||
if err != nil {
|
||||
return nil, errDecodeMasterKeyFailed
|
||||
}
|
||||
c.masterKey, err = crypto.DPAPI(key[5:])
|
||||
c.masterKey, err = crypto.DecryptWithDPAPI(key[5:])
|
||||
if err != nil {
|
||||
slog.Error("decrypt master key failed", "err", err)
|
||||
return nil, err
|
||||
|
||||
@ -86,7 +86,7 @@ func (f *Firefox) GetMasterKey() ([]byte, error) {
|
||||
defer os.Remove(tempFilename)
|
||||
defer keyDB.Close()
|
||||
|
||||
globalSalt, metaBytes, err := queryMetaData(keyDB)
|
||||
metaItem1, metaItem2, err := queryMetaData(keyDB)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("query metadata error: %w", err)
|
||||
}
|
||||
@ -96,16 +96,16 @@ func (f *Firefox) GetMasterKey() ([]byte, error) {
|
||||
return nil, fmt.Errorf("query NSS private error: %w", err)
|
||||
}
|
||||
|
||||
return processMasterKey(globalSalt, metaBytes, nssA11, nssA102)
|
||||
return processMasterKey(metaItem1, metaItem2, nssA11, nssA102)
|
||||
}
|
||||
|
||||
func queryMetaData(db *sql.DB) ([]byte, []byte, error) {
|
||||
const query = `SELECT item1, item2 FROM metaData WHERE id = 'password'`
|
||||
var globalSalt, metaBytes []byte
|
||||
if err := db.QueryRow(query).Scan(&globalSalt, &metaBytes); err != nil {
|
||||
var metaItem1, metaItem2 []byte
|
||||
if err := db.QueryRow(query).Scan(&metaItem1, &metaItem2); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
return globalSalt, metaBytes, nil
|
||||
return metaItem1, metaItem2, nil
|
||||
}
|
||||
|
||||
func queryNssPrivate(db *sql.DB) ([]byte, []byte, error) {
|
||||
@ -119,37 +119,40 @@ func queryNssPrivate(db *sql.DB) ([]byte, []byte, error) {
|
||||
|
||||
// processMasterKey process master key of Firefox.
|
||||
// Process the metaBytes and nssA11 with the corresponding cryptographic operations.
|
||||
func processMasterKey(globalSalt, metaBytes, nssA11, nssA102 []byte) ([]byte, error) {
|
||||
metaPBE, err := crypto.NewASN1PBE(metaBytes)
|
||||
func processMasterKey(metaItem1, metaItem2, nssA11, nssA102 []byte) ([]byte, error) {
|
||||
metaPBE, err := crypto.NewASN1PBE(metaItem2)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, fmt.Errorf("error creating ASN1PBE from metaItem2: %w", err)
|
||||
}
|
||||
|
||||
k, err := metaPBE.Decrypt(globalSalt)
|
||||
flag, err := metaPBE.Decrypt(metaItem1)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, fmt.Errorf("error decrypting master key: %w", err)
|
||||
}
|
||||
const passwordCheck = "password-check"
|
||||
|
||||
if !bytes.Contains(flag, []byte(passwordCheck)) {
|
||||
return nil, errors.New("flag verification failed: password-check not found")
|
||||
}
|
||||
|
||||
if !bytes.Contains(k, []byte("password-check")) {
|
||||
return nil, errors.New("password-check not found")
|
||||
}
|
||||
keyLin := []byte{248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
|
||||
var keyLin = []byte{248, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
|
||||
if !bytes.Equal(nssA102, keyLin) {
|
||||
return nil, errors.New("nssA102 not equal keyLin")
|
||||
return nil, errors.New("master key verification failed: nssA102 not equal to expected value")
|
||||
}
|
||||
nssPBE, err := crypto.NewASN1PBE(nssA11)
|
||||
|
||||
nssA11PBE, err := crypto.NewASN1PBE(nssA11)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, fmt.Errorf("error creating ASN1PBE from nssA11: %w", err)
|
||||
}
|
||||
finallyKey, err := nssPBE.Decrypt(globalSalt)
|
||||
|
||||
finallyKey, err := nssA11PBE.Decrypt(metaItem1)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return nil, fmt.Errorf("error decrypting final key: %w", err)
|
||||
}
|
||||
if len(finallyKey) < 24 {
|
||||
return nil, errors.New("finallyKey length less than 24")
|
||||
return nil, errors.New("length of final key is less than 24 bytes")
|
||||
}
|
||||
finallyKey = finallyKey[:24]
|
||||
return finallyKey, nil
|
||||
return finallyKey[:24], nil
|
||||
}
|
||||
|
||||
func (f *Firefox) Name() string {
|
||||
|
||||
@ -72,9 +72,9 @@ func (c *ChromiumCookie) Parse(masterKey []byte) error {
|
||||
}
|
||||
if len(encryptValue) > 0 {
|
||||
if len(masterKey) == 0 {
|
||||
value, err = crypto.DPAPI(encryptValue)
|
||||
value, err = crypto.DecryptWithDPAPI(encryptValue)
|
||||
} else {
|
||||
value, err = crypto.DecryptPass(masterKey, encryptValue)
|
||||
value, err = crypto.DecryptWithChromium(masterKey, encryptValue)
|
||||
}
|
||||
if err != nil {
|
||||
slog.Error("decrypt chromium cookie error", "err", err)
|
||||
|
||||
@ -59,9 +59,9 @@ func (c *ChromiumCreditCard) Parse(masterKey []byte) error {
|
||||
}
|
||||
if len(encryptValue) > 0 {
|
||||
if len(masterKey) == 0 {
|
||||
value, err = crypto.DPAPI(encryptValue)
|
||||
value, err = crypto.DecryptWithDPAPI(encryptValue)
|
||||
} else {
|
||||
value, err = crypto.DecryptPass(masterKey, encryptValue)
|
||||
value, err = crypto.DecryptWithChromium(masterKey, encryptValue)
|
||||
}
|
||||
if err != nil {
|
||||
slog.Error("decrypt chromium credit card error", "err", err)
|
||||
@ -114,9 +114,9 @@ func (c *YandexCreditCard) Parse(masterKey []byte) error {
|
||||
}
|
||||
if len(encryptValue) > 0 {
|
||||
if len(masterKey) == 0 {
|
||||
value, err = crypto.DPAPI(encryptValue)
|
||||
value, err = crypto.DecryptWithDPAPI(encryptValue)
|
||||
} else {
|
||||
value, err = crypto.DecryptPass(masterKey, encryptValue)
|
||||
value, err = crypto.DecryptWithChromium(masterKey, encryptValue)
|
||||
}
|
||||
if err != nil {
|
||||
slog.Error("decrypt chromium credit card error", "err", err)
|
||||
|
||||
@ -61,9 +61,9 @@ func (c *ChromiumPassword) Parse(masterKey []byte) error {
|
||||
}
|
||||
if len(pwd) > 0 {
|
||||
if len(masterKey) == 0 {
|
||||
password, err = crypto.DPAPI(pwd)
|
||||
password, err = crypto.DecryptWithDPAPI(pwd)
|
||||
} else {
|
||||
password, err = crypto.DecryptPass(masterKey, pwd)
|
||||
password, err = crypto.DecryptWithChromium(masterKey, pwd)
|
||||
}
|
||||
if err != nil {
|
||||
slog.Error("decrypt chromium password error", "err", err)
|
||||
@ -129,9 +129,9 @@ func (c *YandexPassword) Parse(masterKey []byte) error {
|
||||
|
||||
if len(pwd) > 0 {
|
||||
if len(masterKey) == 0 {
|
||||
password, err = crypto.DPAPI(pwd)
|
||||
password, err = crypto.DecryptWithDPAPI(pwd)
|
||||
} else {
|
||||
password, err = crypto.DecryptPass(masterKey, pwd)
|
||||
password, err = crypto.DecryptWithChromium(masterKey, pwd)
|
||||
}
|
||||
if err != nil {
|
||||
slog.Error("decrypt yandex password error", "err", err)
|
||||
@ -162,12 +162,7 @@ func (c *YandexPassword) Len() int {
|
||||
|
||||
type FirefoxPassword []loginData
|
||||
|
||||
const (
|
||||
queryMetaData = `SELECT item1, item2 FROM metaData WHERE id = 'password'`
|
||||
queryNssPrivate = `SELECT a11, a102 from nssPrivate`
|
||||
)
|
||||
|
||||
func (f *FirefoxPassword) Parse(masterKey []byte) error {
|
||||
func (f *FirefoxPassword) Parse(globalSalt []byte) error {
|
||||
logins, err := getFirefoxLoginData()
|
||||
if err != nil {
|
||||
return err
|
||||
@ -182,11 +177,11 @@ func (f *FirefoxPassword) Parse(masterKey []byte) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
user, err := userPBE.Decrypt(masterKey)
|
||||
user, err := userPBE.Decrypt(globalSalt)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
pwd, err := pwdPBE.Decrypt(masterKey)
|
||||
pwd, err := pwdPBE.Decrypt(globalSalt)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
194
crypto/asn1pbe.go
Normal file
194
crypto/asn1pbe.go
Normal file
@ -0,0 +1,194 @@
|
||||
package crypto
|
||||
|
||||
import (
|
||||
"crypto/hmac"
|
||||
"crypto/sha1"
|
||||
"crypto/sha256"
|
||||
"encoding/asn1"
|
||||
"errors"
|
||||
|
||||
"golang.org/x/crypto/pbkdf2"
|
||||
)
|
||||
|
||||
type ASN1PBE interface {
|
||||
Decrypt(globalSalt []byte) ([]byte, error)
|
||||
|
||||
Encrypt(globalSalt, plaintext []byte) ([]byte, error)
|
||||
}
|
||||
|
||||
func NewASN1PBE(b []byte) (pbe ASN1PBE, err error) {
|
||||
var (
|
||||
nss nssPBE
|
||||
meta metaPBE
|
||||
login loginPBE
|
||||
)
|
||||
if _, err := asn1.Unmarshal(b, &nss); err == nil {
|
||||
return nss, nil
|
||||
}
|
||||
if _, err := asn1.Unmarshal(b, &meta); err == nil {
|
||||
return meta, nil
|
||||
}
|
||||
if _, err := asn1.Unmarshal(b, &login); err == nil {
|
||||
return login, nil
|
||||
}
|
||||
return nil, ErrDecodeASN1Failed
|
||||
}
|
||||
|
||||
var ErrDecodeASN1Failed = errors.New("decode ASN1 data failed")
|
||||
|
||||
// nssPBE Struct
|
||||
//
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// SEQUENCE (2 elem)
|
||||
// OCTET STRING (20 byte)
|
||||
// INTEGER 1
|
||||
// OCTET STRING (16 byte)
|
||||
type nssPBE struct {
|
||||
AlgoAttr struct {
|
||||
asn1.ObjectIdentifier
|
||||
SaltAttr struct {
|
||||
EntrySalt []byte
|
||||
Len int
|
||||
}
|
||||
}
|
||||
Encrypted []byte
|
||||
}
|
||||
|
||||
// Decrypt decrypts the encrypted password with the global salt.
|
||||
func (n nssPBE) Decrypt(globalSalt []byte) ([]byte, error) {
|
||||
key, iv := n.deriveKeyAndIV(globalSalt)
|
||||
|
||||
return DES3Decrypt(key, iv, n.Encrypted)
|
||||
}
|
||||
|
||||
func (n nssPBE) Encrypt(globalSalt []byte, plaintext []byte) ([]byte, error) {
|
||||
key, iv := n.deriveKeyAndIV(globalSalt)
|
||||
|
||||
return DES3Encrypt(key, iv, plaintext)
|
||||
}
|
||||
|
||||
// deriveKeyAndIV derives the key and initialization vector (IV)
|
||||
// from the global salt and entry salt.
|
||||
func (n nssPBE) deriveKeyAndIV(globalSalt []byte) ([]byte, []byte) {
|
||||
salt := n.AlgoAttr.SaltAttr.EntrySalt
|
||||
hashPrefix := sha1.Sum(globalSalt)
|
||||
compositeHash := sha1.Sum(append(hashPrefix[:], salt...))
|
||||
paddedEntrySalt := paddingZero(salt, 20)
|
||||
|
||||
hmacProcessor := hmac.New(sha1.New, compositeHash[:])
|
||||
hmacProcessor.Write(paddedEntrySalt)
|
||||
|
||||
paddedEntrySalt = append(paddedEntrySalt, salt...)
|
||||
keyComponent1 := hmac.New(sha1.New, compositeHash[:])
|
||||
keyComponent1.Write(paddedEntrySalt)
|
||||
|
||||
hmacWithSalt := append(hmacProcessor.Sum(nil), salt...)
|
||||
keyComponent2 := hmac.New(sha1.New, compositeHash[:])
|
||||
keyComponent2.Write(hmacWithSalt)
|
||||
|
||||
key := append(keyComponent1.Sum(nil), keyComponent2.Sum(nil)...)
|
||||
iv := key[len(key)-8:]
|
||||
return key[:24], iv
|
||||
}
|
||||
|
||||
// MetaPBE Struct
|
||||
//
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// SEQUENCE (2 elem)
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// SEQUENCE (4 elem)
|
||||
// OCTET STRING (32 byte)
|
||||
// INTEGER 1
|
||||
// INTEGER 32
|
||||
// SEQUENCE (1 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// OCTET STRING (14 byte)
|
||||
// OCTET STRING (16 byte)
|
||||
type metaPBE struct {
|
||||
AlgoAttr algoAttr
|
||||
Encrypted []byte
|
||||
}
|
||||
|
||||
type algoAttr struct {
|
||||
asn1.ObjectIdentifier
|
||||
Data struct {
|
||||
Data struct {
|
||||
asn1.ObjectIdentifier
|
||||
SlatAttr slatAttr
|
||||
}
|
||||
IVData ivAttr
|
||||
}
|
||||
}
|
||||
|
||||
type ivAttr struct {
|
||||
asn1.ObjectIdentifier
|
||||
IV []byte
|
||||
}
|
||||
|
||||
type slatAttr struct {
|
||||
EntrySalt []byte
|
||||
IterationCount int
|
||||
KeySize int
|
||||
Algorithm struct {
|
||||
asn1.ObjectIdentifier
|
||||
}
|
||||
}
|
||||
|
||||
func (m metaPBE) Decrypt(globalSalt []byte) ([]byte, error) {
|
||||
key, iv := m.deriveKeyAndIV(globalSalt)
|
||||
|
||||
return AES128CBCDecrypt(key, iv, m.Encrypted)
|
||||
}
|
||||
|
||||
func (m metaPBE) Encrypt(globalSalt, plaintext []byte) ([]byte, error) {
|
||||
key, iv := m.deriveKeyAndIV(globalSalt)
|
||||
|
||||
return AES128CBCEncrypt(key, iv, plaintext)
|
||||
}
|
||||
|
||||
func (m metaPBE) deriveKeyAndIV(globalSalt []byte) ([]byte, []byte) {
|
||||
password := sha1.Sum(globalSalt)
|
||||
|
||||
salt := m.AlgoAttr.Data.Data.SlatAttr.EntrySalt
|
||||
iter := m.AlgoAttr.Data.Data.SlatAttr.IterationCount
|
||||
keyLen := m.AlgoAttr.Data.Data.SlatAttr.KeySize
|
||||
|
||||
key := pbkdf2.Key(password[:], salt, iter, keyLen, sha256.New)
|
||||
iv := append([]byte{4, 14}, m.AlgoAttr.Data.IVData.IV...)
|
||||
return key, iv
|
||||
}
|
||||
|
||||
// loginPBE Struct
|
||||
//
|
||||
// OCTET STRING (16 byte)
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// OCTET STRING (8 byte)
|
||||
// OCTET STRING (16 byte)
|
||||
type loginPBE struct {
|
||||
CipherText []byte
|
||||
Data struct {
|
||||
asn1.ObjectIdentifier
|
||||
IV []byte
|
||||
}
|
||||
Encrypted []byte
|
||||
}
|
||||
|
||||
func (l loginPBE) Decrypt(globalSalt []byte) ([]byte, error) {
|
||||
key, iv := l.deriveKeyAndIV(globalSalt)
|
||||
return DES3Decrypt(key, iv, l.Encrypted)
|
||||
}
|
||||
|
||||
func (l loginPBE) Encrypt(globalSalt, plaintext []byte) ([]byte, error) {
|
||||
key, iv := l.deriveKeyAndIV(globalSalt)
|
||||
return DES3Encrypt(key, iv, plaintext)
|
||||
}
|
||||
|
||||
func (l loginPBE) deriveKeyAndIV(globalSalt []byte) ([]byte, []byte) {
|
||||
return globalSalt, l.Data.IV
|
||||
}
|
||||
297
crypto/asn1pbe_test.go
Normal file
297
crypto/asn1pbe_test.go
Normal file
@ -0,0 +1,297 @@
|
||||
package crypto
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/asn1"
|
||||
"encoding/hex"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
var (
|
||||
pbeIV = []byte("01234567") // 8 bytes
|
||||
pbePlaintext = []byte("Hello, World!")
|
||||
pbeCipherText = []byte{0xf8, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1}
|
||||
objWithMD5AndDESCBC = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 5, 3}
|
||||
objWithSHA256AndAES = asn1.ObjectIdentifier{2, 16, 840, 1, 101, 3, 4, 1, 46}
|
||||
objWithSHA1AndAES = asn1.ObjectIdentifier{1, 2, 840, 113549, 1, 5, 13}
|
||||
nssPBETestCases = []struct {
|
||||
RawHexPBE string
|
||||
GlobalSalt []byte
|
||||
Encrypted []byte
|
||||
IterationCount int
|
||||
Len int
|
||||
Plaintext []byte
|
||||
ObjectIdentifier asn1.ObjectIdentifier
|
||||
}{
|
||||
{
|
||||
RawHexPBE: "303e302a06092a864886f70d01050d301d04186d6f6f6e6434726b6d6f6f6e6434726b6d6f6f6e6434726b020114041095183a14c752e7b1d0aaa47f53e05097",
|
||||
GlobalSalt: bytes.Repeat([]byte(baseKey), 3),
|
||||
Encrypted: []byte{0x95, 0x18, 0x3a, 0x14, 0xc7, 0x52, 0xe7, 0xb1, 0xd0, 0xaa, 0xa4, 0x7f, 0x53, 0xe0, 0x50, 0x97},
|
||||
Plaintext: pbePlaintext,
|
||||
IterationCount: 1,
|
||||
Len: 32,
|
||||
ObjectIdentifier: objWithSHA1AndAES,
|
||||
},
|
||||
}
|
||||
metaPBETestCases = []struct {
|
||||
RawHexPBE string
|
||||
GlobalSalt []byte
|
||||
Encrypted []byte
|
||||
IV []byte
|
||||
Plaintext []byte
|
||||
ObjectIdentifier asn1.ObjectIdentifier
|
||||
}{
|
||||
{
|
||||
RawHexPBE: "307a3066060960864801650304012e3059303a060960864801650304012e302d04186d6f6f6e6434726b6d6f6f6e6434726b6d6f6f6e6434726b020101020120300b060960864801650304012e301b060960864801650304012e040e303132333435363730313233343504100474679f2e6256518b7adb877beaa154",
|
||||
GlobalSalt: bytes.Repeat([]byte(baseKey), 3),
|
||||
Encrypted: []byte{0x4, 0x74, 0x67, 0x9f, 0x2e, 0x62, 0x56, 0x51, 0x8b, 0x7a, 0xdb, 0x87, 0x7b, 0xea, 0xa1, 0x54},
|
||||
IV: bytes.Repeat(pbeIV, 2)[:14],
|
||||
Plaintext: pbePlaintext,
|
||||
ObjectIdentifier: objWithSHA256AndAES,
|
||||
},
|
||||
}
|
||||
loginPBETestCases = []struct {
|
||||
RawHexPBE string
|
||||
GlobalSalt []byte
|
||||
Encrypted []byte
|
||||
IV []byte
|
||||
Plaintext []byte
|
||||
ObjectIdentifier asn1.ObjectIdentifier
|
||||
}{
|
||||
{
|
||||
RawHexPBE: "303b0410f8000000000000000000000000000001301506092a864886f70d010503040830313233343536370410fe968b6565149114ea688defd6683e45303b0410f8000000000000000000000000000001301506092a864886f70d010503040830313233343536370410fe968b6565149114ea688defd6683e45303b0410f8000000000000000000000000000001301506092a864886f70d010503040830313233343536370410fe968b6565149114ea688defd6683e45",
|
||||
Encrypted: []byte{0xfe, 0x96, 0x8b, 0x65, 0x65, 0x14, 0x91, 0x14, 0xea, 0x68, 0x8d, 0xef, 0xd6, 0x68, 0x3e, 0x45},
|
||||
GlobalSalt: bytes.Repeat([]byte(baseKey), 3),
|
||||
IV: pbeIV,
|
||||
Plaintext: pbePlaintext,
|
||||
ObjectIdentifier: objWithMD5AndDESCBC,
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
func TestNewASN1PBE(t *testing.T) {
|
||||
for _, tc := range nssPBETestCases {
|
||||
nssRaw, err := hex.DecodeString(tc.RawHexPBE)
|
||||
assert.Equal(t, nil, err)
|
||||
pbe, err := NewASN1PBE(nssRaw)
|
||||
assert.Equal(t, nil, err)
|
||||
nssPBETC, ok := pbe.(nssPBE)
|
||||
assert.Equal(t, true, ok)
|
||||
assert.Equal(t, nssPBETC.Encrypted, tc.Encrypted)
|
||||
assert.Equal(t, nssPBETC.AlgoAttr.SaltAttr.EntrySalt, tc.GlobalSalt)
|
||||
assert.Equal(t, nssPBETC.AlgoAttr.SaltAttr.Len, 20)
|
||||
assert.Equal(t, nssPBETC.AlgoAttr.ObjectIdentifier, tc.ObjectIdentifier)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNssPBE_Encrypt(t *testing.T) {
|
||||
for _, tc := range nssPBETestCases {
|
||||
nssPBETC := nssPBE{
|
||||
Encrypted: tc.Encrypted,
|
||||
AlgoAttr: struct {
|
||||
asn1.ObjectIdentifier
|
||||
SaltAttr struct {
|
||||
EntrySalt []byte
|
||||
Len int
|
||||
}
|
||||
}{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
SaltAttr: struct {
|
||||
EntrySalt []byte
|
||||
Len int
|
||||
}{
|
||||
EntrySalt: tc.GlobalSalt,
|
||||
Len: 20,
|
||||
},
|
||||
},
|
||||
}
|
||||
encrypted, err := nssPBETC.Encrypt(tc.GlobalSalt, tc.Plaintext)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(encrypted) > 0)
|
||||
assert.Equal(t, nssPBETC.Encrypted, encrypted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNssPBE_Decrypt(t *testing.T) {
|
||||
for _, tc := range nssPBETestCases {
|
||||
nssPBETC := nssPBE{
|
||||
Encrypted: tc.Encrypted,
|
||||
AlgoAttr: struct {
|
||||
asn1.ObjectIdentifier
|
||||
SaltAttr struct {
|
||||
EntrySalt []byte
|
||||
Len int
|
||||
}
|
||||
}{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
SaltAttr: struct {
|
||||
EntrySalt []byte
|
||||
Len int
|
||||
}{
|
||||
EntrySalt: tc.GlobalSalt,
|
||||
Len: 20,
|
||||
},
|
||||
},
|
||||
}
|
||||
decrypted, err := nssPBETC.Decrypt(tc.GlobalSalt)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(decrypted) > 0)
|
||||
assert.Equal(t, pbePlaintext, decrypted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewASN1PBE_MetaPBE(t *testing.T) {
|
||||
for _, tc := range metaPBETestCases {
|
||||
metaRaw, err := hex.DecodeString(tc.RawHexPBE)
|
||||
assert.Equal(t, nil, err)
|
||||
pbe, err := NewASN1PBE(metaRaw)
|
||||
assert.Equal(t, nil, err)
|
||||
metaPBETC, ok := pbe.(metaPBE)
|
||||
assert.Equal(t, true, ok)
|
||||
assert.Equal(t, metaPBETC.Encrypted, tc.Encrypted)
|
||||
assert.Equal(t, metaPBETC.AlgoAttr.Data.IVData.IV, tc.IV)
|
||||
assert.Equal(t, metaPBETC.AlgoAttr.Data.IVData.ObjectIdentifier, objWithSHA256AndAES)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMetaPBE_Encrypt(t *testing.T) {
|
||||
for _, tc := range metaPBETestCases {
|
||||
metaPBETC := metaPBE{
|
||||
AlgoAttr: algoAttr{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
Data: struct {
|
||||
Data struct {
|
||||
asn1.ObjectIdentifier
|
||||
SlatAttr slatAttr
|
||||
}
|
||||
IVData ivAttr
|
||||
}{
|
||||
Data: struct {
|
||||
asn1.ObjectIdentifier
|
||||
SlatAttr slatAttr
|
||||
}{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
SlatAttr: slatAttr{
|
||||
EntrySalt: tc.GlobalSalt,
|
||||
IterationCount: 1,
|
||||
KeySize: 32,
|
||||
Algorithm: struct {
|
||||
asn1.ObjectIdentifier
|
||||
}{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
},
|
||||
},
|
||||
},
|
||||
IVData: ivAttr{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
IV: tc.IV,
|
||||
},
|
||||
},
|
||||
},
|
||||
Encrypted: tc.Encrypted,
|
||||
}
|
||||
encrypted, err := metaPBETC.Encrypt(tc.GlobalSalt, tc.Plaintext)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(encrypted) > 0)
|
||||
assert.Equal(t, metaPBETC.Encrypted, encrypted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMetaPBE_Decrypt(t *testing.T) {
|
||||
for _, tc := range metaPBETestCases {
|
||||
metaPBETC := metaPBE{
|
||||
AlgoAttr: algoAttr{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
Data: struct {
|
||||
Data struct {
|
||||
asn1.ObjectIdentifier
|
||||
SlatAttr slatAttr
|
||||
}
|
||||
IVData ivAttr
|
||||
}{
|
||||
Data: struct {
|
||||
asn1.ObjectIdentifier
|
||||
SlatAttr slatAttr
|
||||
}{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
SlatAttr: slatAttr{
|
||||
EntrySalt: tc.GlobalSalt,
|
||||
IterationCount: 1,
|
||||
KeySize: 32,
|
||||
Algorithm: struct {
|
||||
asn1.ObjectIdentifier
|
||||
}{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
},
|
||||
},
|
||||
},
|
||||
IVData: ivAttr{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
IV: tc.IV,
|
||||
},
|
||||
},
|
||||
},
|
||||
Encrypted: tc.Encrypted,
|
||||
}
|
||||
decrypted, err := metaPBETC.Decrypt(tc.GlobalSalt)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(decrypted) > 0)
|
||||
assert.Equal(t, pbePlaintext, decrypted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewASN1PBE_LoginPBE(t *testing.T) {
|
||||
for _, tc := range loginPBETestCases {
|
||||
loginRaw, err := hex.DecodeString(tc.RawHexPBE)
|
||||
assert.Equal(t, nil, err)
|
||||
pbe, err := NewASN1PBE(loginRaw)
|
||||
assert.Equal(t, nil, err)
|
||||
loginPBETC, ok := pbe.(loginPBE)
|
||||
assert.Equal(t, true, ok)
|
||||
assert.Equal(t, loginPBETC.Encrypted, tc.Encrypted)
|
||||
assert.Equal(t, loginPBETC.Data.IV, tc.IV)
|
||||
assert.Equal(t, loginPBETC.Data.ObjectIdentifier, objWithMD5AndDESCBC)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoginPBE_Encrypt(t *testing.T) {
|
||||
for _, tc := range loginPBETestCases {
|
||||
loginPBETC := loginPBE{
|
||||
CipherText: pbeCipherText,
|
||||
Data: struct {
|
||||
asn1.ObjectIdentifier
|
||||
IV []byte
|
||||
}{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
IV: tc.IV,
|
||||
},
|
||||
Encrypted: tc.Encrypted,
|
||||
}
|
||||
encrypted, err := loginPBETC.Encrypt(tc.GlobalSalt, plainText)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(encrypted) > 0)
|
||||
assert.Equal(t, loginPBETC.Encrypted, encrypted)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoginPBE_Decrypt(t *testing.T) {
|
||||
for _, tc := range loginPBETestCases {
|
||||
loginPBETC := loginPBE{
|
||||
CipherText: pbeCipherText,
|
||||
Data: struct {
|
||||
asn1.ObjectIdentifier
|
||||
IV []byte
|
||||
}{
|
||||
ObjectIdentifier: tc.ObjectIdentifier,
|
||||
IV: tc.IV,
|
||||
},
|
||||
Encrypted: tc.Encrypted,
|
||||
}
|
||||
decrypted, err := loginPBETC.Decrypt(tc.GlobalSalt)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(decrypted) > 0)
|
||||
assert.Equal(t, pbePlaintext, decrypted)
|
||||
}
|
||||
}
|
||||
324
crypto/crypto.go
324
crypto/crypto.go
@ -1,238 +1,150 @@
|
||||
package crypto
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/aes"
|
||||
"crypto/cipher"
|
||||
"crypto/des"
|
||||
"crypto/hmac"
|
||||
"crypto/sha1"
|
||||
"crypto/sha256"
|
||||
"encoding/asn1"
|
||||
"errors"
|
||||
|
||||
"golang.org/x/crypto/pbkdf2"
|
||||
"fmt"
|
||||
)
|
||||
|
||||
var (
|
||||
errPasswordIsEmpty = errors.New("password is empty")
|
||||
errDecodeASN1Failed = errors.New("decode ASN1 data failed")
|
||||
errEncryptedLength = errors.New("length of encrypted password less than block size")
|
||||
ErrCiphertextLengthIsInvalid = errors.New("ciphertext length is invalid")
|
||||
)
|
||||
|
||||
type ASN1PBE interface {
|
||||
Decrypt(globalSalt []byte) (key []byte, err error)
|
||||
}
|
||||
|
||||
func NewASN1PBE(b []byte) (pbe ASN1PBE, err error) {
|
||||
var (
|
||||
n nssPBE
|
||||
m metaPBE
|
||||
l loginPBE
|
||||
)
|
||||
if _, err := asn1.Unmarshal(b, &n); err == nil {
|
||||
return n, nil
|
||||
}
|
||||
if _, err := asn1.Unmarshal(b, &m); err == nil {
|
||||
return m, nil
|
||||
}
|
||||
if _, err := asn1.Unmarshal(b, &l); err == nil {
|
||||
return l, nil
|
||||
}
|
||||
return nil, errDecodeASN1Failed
|
||||
}
|
||||
|
||||
// nssPBE Struct
|
||||
//
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// SEQUENCE (2 elem)
|
||||
// OCTET STRING (20 byte)
|
||||
// INTEGER 1
|
||||
// OCTET STRING (16 byte)
|
||||
type nssPBE struct {
|
||||
AlgoAttr struct {
|
||||
asn1.ObjectIdentifier
|
||||
SaltAttr struct {
|
||||
EntrySalt []byte
|
||||
Len int
|
||||
}
|
||||
}
|
||||
Encrypted []byte
|
||||
}
|
||||
|
||||
func (n nssPBE) Decrypt(globalSalt []byte) (key []byte, err error) {
|
||||
hp := sha1.Sum(globalSalt)
|
||||
s := append(hp[:], n.salt()...)
|
||||
chp := sha1.Sum(s)
|
||||
pes := paddingZero(n.salt(), 20)
|
||||
tk := hmac.New(sha1.New, chp[:])
|
||||
tk.Write(pes)
|
||||
pes = append(pes, n.salt()...)
|
||||
k1 := hmac.New(sha1.New, chp[:])
|
||||
k1.Write(pes)
|
||||
tkPlus := append(tk.Sum(nil), n.salt()...)
|
||||
k2 := hmac.New(sha1.New, chp[:])
|
||||
k2.Write(tkPlus)
|
||||
k := append(k1.Sum(nil), k2.Sum(nil)...)
|
||||
iv := k[len(k)-8:]
|
||||
return des3Decrypt(k[:24], iv, n.encrypted())
|
||||
}
|
||||
|
||||
func (n nssPBE) salt() []byte {
|
||||
return n.AlgoAttr.SaltAttr.EntrySalt
|
||||
}
|
||||
|
||||
func (n nssPBE) encrypted() []byte {
|
||||
return n.Encrypted
|
||||
}
|
||||
|
||||
// MetaPBE Struct
|
||||
//
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// SEQUENCE (2 elem)
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// SEQUENCE (4 elem)
|
||||
// OCTET STRING (32 byte)
|
||||
// INTEGER 1
|
||||
// INTEGER 32
|
||||
// SEQUENCE (1 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// OCTET STRING (14 byte)
|
||||
// OCTET STRING (16 byte)
|
||||
type metaPBE struct {
|
||||
AlgoAttr algoAttr
|
||||
Encrypted []byte
|
||||
}
|
||||
|
||||
type algoAttr struct {
|
||||
asn1.ObjectIdentifier
|
||||
Data struct {
|
||||
Data struct {
|
||||
asn1.ObjectIdentifier
|
||||
SlatAttr slatAttr
|
||||
}
|
||||
IVData ivAttr
|
||||
}
|
||||
}
|
||||
|
||||
type ivAttr struct {
|
||||
asn1.ObjectIdentifier
|
||||
IV []byte
|
||||
}
|
||||
|
||||
type slatAttr struct {
|
||||
EntrySalt []byte
|
||||
IterationCount int
|
||||
KeySize int
|
||||
Algorithm struct {
|
||||
asn1.ObjectIdentifier
|
||||
}
|
||||
}
|
||||
|
||||
func (m metaPBE) Decrypt(globalSalt []byte) (key2 []byte, err error) {
|
||||
k := sha1.Sum(globalSalt)
|
||||
key := pbkdf2.Key(k[:], m.salt(), m.iterationCount(), m.keySize(), sha256.New)
|
||||
iv := append([]byte{4, 14}, m.iv()...)
|
||||
return aes128CBCDecrypt(key, iv, m.encrypted())
|
||||
}
|
||||
|
||||
func (m metaPBE) salt() []byte {
|
||||
return m.AlgoAttr.Data.Data.SlatAttr.EntrySalt
|
||||
}
|
||||
|
||||
func (m metaPBE) iterationCount() int {
|
||||
return m.AlgoAttr.Data.Data.SlatAttr.IterationCount
|
||||
}
|
||||
|
||||
func (m metaPBE) keySize() int {
|
||||
return m.AlgoAttr.Data.Data.SlatAttr.KeySize
|
||||
}
|
||||
|
||||
func (m metaPBE) iv() []byte {
|
||||
return m.AlgoAttr.Data.IVData.IV
|
||||
}
|
||||
|
||||
func (m metaPBE) encrypted() []byte {
|
||||
return m.Encrypted
|
||||
}
|
||||
|
||||
// loginPBE Struct
|
||||
//
|
||||
// OCTET STRING (16 byte)
|
||||
// SEQUENCE (2 elem)
|
||||
// OBJECT IDENTIFIER
|
||||
// OCTET STRING (8 byte)
|
||||
// OCTET STRING (16 byte)
|
||||
type loginPBE struct {
|
||||
CipherText []byte
|
||||
Data struct {
|
||||
asn1.ObjectIdentifier
|
||||
IV []byte
|
||||
}
|
||||
Encrypted []byte
|
||||
}
|
||||
|
||||
func (l loginPBE) Decrypt(globalSalt []byte) (key []byte, err error) {
|
||||
return des3Decrypt(globalSalt, l.iv(), l.encrypted())
|
||||
}
|
||||
|
||||
func (l loginPBE) iv() []byte {
|
||||
return l.Data.IV
|
||||
}
|
||||
|
||||
func (l loginPBE) encrypted() []byte {
|
||||
return l.Encrypted
|
||||
}
|
||||
|
||||
func aes128CBCDecrypt(key, iv, encryptPass []byte) ([]byte, error) {
|
||||
func AES128CBCDecrypt(key, iv, ciphertext []byte) ([]byte, error) {
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
encryptLen := len(encryptPass)
|
||||
if encryptLen < block.BlockSize() {
|
||||
return nil, errEncryptedLength
|
||||
// Check ciphertext length
|
||||
if len(ciphertext) < aes.BlockSize {
|
||||
return nil, errors.New("AES128CBCDecrypt: ciphertext too short")
|
||||
}
|
||||
if len(ciphertext)%aes.BlockSize != 0 {
|
||||
return nil, errors.New("AES128CBCDecrypt: ciphertext is not a multiple of the block size")
|
||||
}
|
||||
|
||||
dst := make([]byte, encryptLen)
|
||||
decryptedData := make([]byte, len(ciphertext))
|
||||
mode := cipher.NewCBCDecrypter(block, iv)
|
||||
mode.CryptBlocks(dst, encryptPass)
|
||||
dst = pkcs5UnPadding(dst, block.BlockSize())
|
||||
return dst, nil
|
||||
}
|
||||
mode.CryptBlocks(decryptedData, ciphertext)
|
||||
|
||||
func pkcs5UnPadding(src []byte, blockSize int) []byte {
|
||||
n := len(src)
|
||||
paddingNum := int(src[n-1])
|
||||
if n < paddingNum || paddingNum > blockSize {
|
||||
return src
|
||||
// unpad the decrypted data and handle potential padding errors
|
||||
decryptedData, err = pkcs5UnPadding(decryptedData)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("AES128CBCDecrypt: %w", err)
|
||||
}
|
||||
return src[:n-paddingNum]
|
||||
|
||||
return decryptedData, nil
|
||||
}
|
||||
|
||||
// des3Decrypt use for decrypt firefox PBE
|
||||
func des3Decrypt(key, iv []byte, src []byte) ([]byte, error) {
|
||||
func AES128CBCEncrypt(key, iv, plaintext []byte) ([]byte, error) {
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if len(iv) != aes.BlockSize {
|
||||
return nil, errors.New("AES128CBCEncrypt: iv length is invalid, must equal block size")
|
||||
}
|
||||
|
||||
plaintext = pkcs5Padding(plaintext, block.BlockSize())
|
||||
encryptedData := make([]byte, len(plaintext))
|
||||
mode := cipher.NewCBCEncrypter(block, iv)
|
||||
mode.CryptBlocks(encryptedData, plaintext)
|
||||
|
||||
return encryptedData, nil
|
||||
}
|
||||
|
||||
func DES3Decrypt(key, iv []byte, ciphertext []byte) ([]byte, error) {
|
||||
block, err := des.NewTripleDESCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if len(ciphertext) < des.BlockSize {
|
||||
return nil, errors.New("DES3Decrypt: ciphertext too short")
|
||||
}
|
||||
if len(ciphertext)%block.BlockSize() != 0 {
|
||||
return nil, errors.New("DES3Decrypt: ciphertext is not a multiple of the block size")
|
||||
}
|
||||
|
||||
blockMode := cipher.NewCBCDecrypter(block, iv)
|
||||
sq := make([]byte, len(src))
|
||||
blockMode.CryptBlocks(sq, src)
|
||||
return pkcs5UnPadding(sq, block.BlockSize()), nil
|
||||
sq := make([]byte, len(ciphertext))
|
||||
blockMode.CryptBlocks(sq, ciphertext)
|
||||
|
||||
return pkcs5UnPadding(sq)
|
||||
}
|
||||
|
||||
func paddingZero(s []byte, l int) []byte {
|
||||
h := l - len(s)
|
||||
if h <= 0 {
|
||||
return s
|
||||
func DES3Encrypt(key, iv []byte, plaintext []byte) ([]byte, error) {
|
||||
block, err := des.NewTripleDESCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for i := len(s); i < l; i++ {
|
||||
s = append(s, 0)
|
||||
}
|
||||
return s
|
||||
|
||||
plaintext = pkcs5Padding(plaintext, block.BlockSize())
|
||||
dst := make([]byte, len(plaintext))
|
||||
blockMode := cipher.NewCBCEncrypter(block, iv)
|
||||
blockMode.CryptBlocks(dst, plaintext)
|
||||
|
||||
return dst, nil
|
||||
}
|
||||
|
||||
// AESGCMDecrypt chromium > 80 https://source.chromium.org/chromium/chromium/src/+/master:components/os_crypt/os_crypt_win.cc
|
||||
func AESGCMDecrypt(key, nounce, ciphertext []byte) ([]byte, error) {
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
blockMode, err := cipher.NewGCM(block)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
origData, err := blockMode.Open(nil, nounce, ciphertext, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return origData, nil
|
||||
}
|
||||
|
||||
// AESGCMEncrypt encrypts plaintext using AES encryption in GCM mode.
|
||||
func AESGCMEncrypt(key, nonce, plaintext []byte) ([]byte, error) {
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
blockMode, err := cipher.NewGCM(block)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// The first parameter is the prefix for the output, we can leave it nil.
|
||||
// The Seal method encrypts and authenticates the data, appending the result to the dst.
|
||||
encryptedData := blockMode.Seal(nil, nonce, plaintext, nil)
|
||||
return encryptedData, nil
|
||||
}
|
||||
|
||||
func paddingZero(src []byte, length int) []byte {
|
||||
padding := length - len(src)
|
||||
if padding <= 0 {
|
||||
return src
|
||||
}
|
||||
return append(src, make([]byte, padding)...)
|
||||
}
|
||||
|
||||
func pkcs5UnPadding(src []byte) ([]byte, error) {
|
||||
length := len(src)
|
||||
if length == 0 {
|
||||
return nil, errors.New("pkcs5UnPadding: src should not be empty")
|
||||
}
|
||||
padding := int(src[length-1])
|
||||
if padding < 1 || padding > aes.BlockSize {
|
||||
return nil, errors.New("pkcs5UnPadding: invalid padding size")
|
||||
}
|
||||
return src[:length-padding], nil
|
||||
}
|
||||
|
||||
func pkcs5Padding(src []byte, blocksize int) []byte {
|
||||
padding := blocksize - (len(src) % blocksize)
|
||||
padText := bytes.Repeat([]byte{byte(padding)}, padding)
|
||||
return append(src, padText...)
|
||||
}
|
||||
|
||||
@ -2,15 +2,14 @@
|
||||
|
||||
package crypto
|
||||
|
||||
var iv = []byte{32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32}
|
||||
|
||||
func DecryptPass(key, encryptPass []byte) ([]byte, error) {
|
||||
if len(encryptPass) <= 3 {
|
||||
return nil, errPasswordIsEmpty
|
||||
func DecryptWithChromium(key, password []byte) ([]byte, error) {
|
||||
if len(password) <= 3 {
|
||||
return nil, ErrCiphertextLengthIsInvalid
|
||||
}
|
||||
return aes128CBCDecrypt(key, iv, encryptPass[3:])
|
||||
var iv = []byte{32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32}
|
||||
return AES128CBCDecrypt(key, iv, password[3:])
|
||||
}
|
||||
|
||||
func DPAPI(_ []byte) ([]byte, error) {
|
||||
func DecryptWithDPAPI(_ []byte) ([]byte, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
@ -2,15 +2,14 @@
|
||||
|
||||
package crypto
|
||||
|
||||
var iv = []byte{32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32}
|
||||
|
||||
func DecryptPass(key, encryptPass []byte) ([]byte, error) {
|
||||
func DecryptWithChromium(key, encryptPass []byte) ([]byte, error) {
|
||||
if len(encryptPass) < 3 {
|
||||
return nil, errPasswordIsEmpty
|
||||
return nil, ErrCiphertextLengthIsInvalid
|
||||
}
|
||||
return aes128CBCDecrypt(key, iv, encryptPass[3:])
|
||||
var iv = []byte{32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32}
|
||||
return AES128CBCDecrypt(key, iv, encryptPass[3:])
|
||||
}
|
||||
|
||||
func DPAPI(_ []byte) ([]byte, error) {
|
||||
func DecryptWithDPAPI(_ []byte) ([]byte, error) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
72
crypto/crypto_test.go
Normal file
72
crypto/crypto_test.go
Normal file
@ -0,0 +1,72 @@
|
||||
package crypto
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"crypto/sha1"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
const baseKey = "moond4rk"
|
||||
|
||||
var (
|
||||
aesKey = bytes.Repeat([]byte(baseKey), 2) // 16 bytes
|
||||
aesIV = []byte("01234567abcdef01") // 16 bytes
|
||||
plainText = []byte("Hello, World!")
|
||||
aes128Ciphertext = "19381468ecf824c0bfc7a89eed9777d2"
|
||||
|
||||
des3Key = sha1.New().Sum(aesKey)[:24]
|
||||
des3IV = aesIV[:8]
|
||||
des3Ciphertext = "a4492f31bc404fae18d53a46ca79282e"
|
||||
|
||||
aesGCMNonce = aesKey[:12]
|
||||
aesGCMCiphertext = "6c49dac89992639713edab3a114c450968a08b53556872cea3919e2e9a"
|
||||
)
|
||||
|
||||
func TestAES128CBCEncrypt(t *testing.T) {
|
||||
encrypted, err := AES128CBCEncrypt(aesKey, aesIV, plainText)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(encrypted) > 0)
|
||||
assert.Equal(t, aes128Ciphertext, fmt.Sprintf("%x", encrypted))
|
||||
}
|
||||
|
||||
func TestAES128CBCDecrypt(t *testing.T) {
|
||||
ciphertext, _ := hex.DecodeString(aes128Ciphertext)
|
||||
decrypted, err := AES128CBCDecrypt(aesKey, aesIV, ciphertext)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(decrypted) > 0)
|
||||
assert.Equal(t, plainText, decrypted)
|
||||
}
|
||||
|
||||
func TestDES3Encrypt(t *testing.T) {
|
||||
encrypted, err := DES3Encrypt(des3Key, des3IV, plainText)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(encrypted) > 0)
|
||||
assert.Equal(t, des3Ciphertext, fmt.Sprintf("%x", encrypted))
|
||||
}
|
||||
|
||||
func TestDES3Decrypt(t *testing.T) {
|
||||
ciphertext, _ := hex.DecodeString(des3Ciphertext)
|
||||
decrypted, err := DES3Decrypt(des3Key, des3IV, ciphertext)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(decrypted) > 0)
|
||||
assert.Equal(t, plainText, decrypted)
|
||||
}
|
||||
|
||||
func TestAESGCMEncrypt(t *testing.T) {
|
||||
encrypted, err := AESGCMEncrypt(aesKey, aesGCMNonce, plainText)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(encrypted) > 0)
|
||||
assert.Equal(t, aesGCMCiphertext, fmt.Sprintf("%x", encrypted))
|
||||
}
|
||||
|
||||
func TestAESGCMDecrypt(t *testing.T) {
|
||||
ciphertext, _ := hex.DecodeString(aesGCMCiphertext)
|
||||
decrypted, err := AESGCMDecrypt(aesKey, aesGCMNonce, ciphertext)
|
||||
assert.Equal(t, nil, err)
|
||||
assert.Equal(t, true, len(decrypted) > 0)
|
||||
assert.Equal(t, plainText, decrypted)
|
||||
}
|
||||
@ -3,47 +3,41 @@
|
||||
package crypto
|
||||
|
||||
import (
|
||||
"crypto/aes"
|
||||
"crypto/cipher"
|
||||
"fmt"
|
||||
"syscall"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
func DecryptPass(key, encryptPass []byte) ([]byte, error) {
|
||||
if len(encryptPass) < 15 {
|
||||
return nil, errPasswordIsEmpty
|
||||
const (
|
||||
// Assuming the nonce size is 12 bytes and the minimum encrypted data size is 3 bytes
|
||||
minEncryptedDataSize = 15
|
||||
nonceSize = 12
|
||||
)
|
||||
|
||||
func DecryptWithChromium(key, ciphertext []byte) ([]byte, error) {
|
||||
if len(ciphertext) < minEncryptedDataSize {
|
||||
return nil, ErrCiphertextLengthIsInvalid
|
||||
}
|
||||
|
||||
return aesGCMDecrypt(encryptPass[15:], key, encryptPass[3:15])
|
||||
nonce := ciphertext[3 : 3+nonceSize]
|
||||
encryptedPassword := ciphertext[3+nonceSize:]
|
||||
|
||||
return AESGCMDecrypt(key, nonce, encryptedPassword)
|
||||
}
|
||||
|
||||
func DecryptPassForYandex(key, encryptPass []byte) ([]byte, error) {
|
||||
if len(encryptPass) < 3 {
|
||||
return nil, errPasswordIsEmpty
|
||||
// DecryptWithYandex decrypts the password with AES-GCM
|
||||
func DecryptWithYandex(key, ciphertext []byte) ([]byte, error) {
|
||||
if len(ciphertext) < minEncryptedDataSize {
|
||||
return nil, ErrCiphertextLengthIsInvalid
|
||||
}
|
||||
// remove Prefix 'v10'
|
||||
// gcmBlockSize = 16
|
||||
// gcmTagSize = 16
|
||||
// gcmMinimumTagSize = 12 // NIST SP 800-38D recommends tags with 12 or more bytes.
|
||||
// gcmStandardNonceSize = 12
|
||||
return aesGCMDecrypt(encryptPass[12:], key, encryptPass[0:12])
|
||||
}
|
||||
|
||||
// chromium > 80 https://source.chromium.org/chromium/chromium/src/+/master:components/os_crypt/os_crypt_win.cc
|
||||
func aesGCMDecrypt(encrypted, key, nounce []byte) ([]byte, error) {
|
||||
block, err := aes.NewCipher(key)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
blockMode, err := cipher.NewGCM(block)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
origData, err := blockMode.Open(nil, nounce, encrypted, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return origData, nil
|
||||
nonce := ciphertext[3 : 3+nonceSize]
|
||||
encryptedPassword := ciphertext[3+nonceSize:]
|
||||
return AESGCMDecrypt(key, nonce, encryptedPassword)
|
||||
}
|
||||
|
||||
type dataBlob struct {
|
||||
@ -61,27 +55,32 @@ func newBlob(d []byte) *dataBlob {
|
||||
}
|
||||
}
|
||||
|
||||
func (b *dataBlob) ToByteArray() []byte {
|
||||
func (b *dataBlob) bytes() []byte {
|
||||
d := make([]byte, b.cbData)
|
||||
copy(d, (*[1 << 30]byte)(unsafe.Pointer(b.pbData))[:])
|
||||
return d
|
||||
}
|
||||
|
||||
// DPAPI (Data Protection Application Programming Interface)
|
||||
// DecryptWithDPAPI (Data Protection Application Programming Interface)
|
||||
// is a simple cryptographic application programming interface
|
||||
// available as a built-in component in Windows 2000 and
|
||||
// later versions of Microsoft Windows operating systems
|
||||
// chrome < 80 https://chromium.googlesource.com/chromium/src/+/76f496a7235c3432983421402951d73905c8be96/components/os_crypt/os_crypt_win.cc#82
|
||||
func DPAPI(data []byte) ([]byte, error) {
|
||||
dllCrypt := syscall.NewLazyDLL("Crypt32.dll")
|
||||
dllKernel := syscall.NewLazyDLL("Kernel32.dll")
|
||||
procDecryptData := dllCrypt.NewProc("CryptUnprotectData")
|
||||
procLocalFree := dllKernel.NewProc("LocalFree")
|
||||
func DecryptWithDPAPI(ciphertext []byte) ([]byte, error) {
|
||||
crypt32 := syscall.NewLazyDLL("Crypt32.dll")
|
||||
kernel32 := syscall.NewLazyDLL("Kernel32.dll")
|
||||
unprotectDataProc := crypt32.NewProc("CryptUnprotectData")
|
||||
localFreeProc := kernel32.NewProc("LocalFree")
|
||||
|
||||
var outBlob dataBlob
|
||||
r, _, err := procDecryptData.Call(uintptr(unsafe.Pointer(newBlob(data))), 0, 0, 0, 0, 0, uintptr(unsafe.Pointer(&outBlob)))
|
||||
r, _, err := unprotectDataProc.Call(
|
||||
uintptr(unsafe.Pointer(newBlob(ciphertext))),
|
||||
0, 0, 0, 0, 0,
|
||||
uintptr(unsafe.Pointer(&outBlob)),
|
||||
)
|
||||
if r == 0 {
|
||||
return nil, err
|
||||
return nil, fmt.Errorf("CryptUnprotectData failed with error %w", err)
|
||||
}
|
||||
defer procLocalFree.Call(uintptr(unsafe.Pointer(outBlob.pbData)))
|
||||
return outBlob.ToByteArray(), nil
|
||||
|
||||
defer localFreeProc.Call(uintptr(unsafe.Pointer(outBlob.pbData)))
|
||||
return outBlob.bytes(), nil
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user