1095 lines
34 KiB
Go
1095 lines
34 KiB
Go
package bip85
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/tyler-smith/go-bip39"
|
|
)
|
|
|
|
const (
|
|
// Test master BIP32 root key from the BIP85 specification
|
|
testMasterKey = "xprv9s21ZrQH143K2LBWUUQRFXhucrQqBpKdRRxNVq2zBqsx8HVqFk2uYo8kmbaLLHRdqtQpUm98uKfu3vca1LqdGhUtyoFnCNkfmXRyPXLjbKb"
|
|
|
|
// Test Case 1 - Basic entropy derivation with path m/83696968'/0'/0'
|
|
testCase1Path = "m/83696968'/0'/0'"
|
|
testCase1ExpectedDerivedKey = "cca20ccb0e9a90feb0912870c3323b24874b0ca3d8018c4b96d0b97c0e82ded0"
|
|
testCase1ExpectedEntropy = "efecfbccffea313214232d29e71563d941229afb4338c21f9517c41aaa0d16f00b83d2a09ef747e7a64e8e2bd5a14869e693da66ce94ac2da570ab7ee48618f7"
|
|
|
|
// Test Case 2 - Basic entropy derivation with path m/83696968'/0'/1'
|
|
testCase2Path = "m/83696968'/0'/1'"
|
|
testCase2ExpectedDerivedKey = "503776919131758bb7de7beb6c0ae24894f4ec042c26032890c29359216e21ba"
|
|
testCase2ExpectedEntropy = "70c6e3e8ebee8dc4c0dbba66076819bb8c09672527c4277ca8729532ad711872218f826919f6b67218adde99018a6df9095ab2b58d803b5b93ec9802085a690e"
|
|
|
|
// BIP85-DRNG-SHAKE256 test vector
|
|
drngTestPath = "m/83696968'/0'/0'"
|
|
drngExpected80Bytes = "b78b1ee6b345eae6836c2d53d33c64cdaf9a696487be81b03e822dc84b3f1cd883d7559e53d175f243e4c349e822a957bbff9224bc5dde9492ef54e8a439f6bc8c7355b87a925a37ee405a7502991111"
|
|
|
|
// Python DRNG test vectors
|
|
pythonDRNG50BytesExpected = "b78b1ee6b345eae6836c2d53d33c64cdaf9a696487be81b03e822dc84b3f1cd883d7559e53d175f243e4c349e822a957bbff"
|
|
pythonDRNG100BytesExpected = "9224bc5dde9492ef54e8a439f6bc8c7355b87a925a37ee405a7502991111cd2dddaf1883f4e962abf4fb4b31cd28d5cf6b14f6ddcc9c19fd56d7f960a4b27f1d423a55dda4865aa6ddd6b4c26f18d400bb0a593e6c785d6d7e28c9c64608624318eddc01"
|
|
pythonDRNG150BytesExpected = "23750caa2a271f35faa6a3ca292b4be357404eca6842c69a3717dc3e41f7b38c67be492395b32221470aa08a2c489018c635a175f731245330e1f47091dbfb26f2923d10bd2e09280bffd1d94eb2a88f964aeb1774da04aad3bb1fdde0f77cd5ca79617ae317375417a51339523057bebef434c4400303890332e458425242f56a4293dad4f632b82713467b18ed6e1dab633220523d"
|
|
pythonDRNG20BytesExpected = "b78b1ee6b345eae6836c2d53d33c64cdaf9a6964"
|
|
pythonDRNG25BytesExpected = "87be81b03e822dc84b3f1cd883d7559e53d175f243e4c349e8"
|
|
|
|
// BIP39 12 English words test vector
|
|
bip39_12WordsPath = "m/83696968'/39'/0'/12'/0'"
|
|
bip39_12WordsExpectedEntropy = "6250b68daf746d12a24d58b4787a714b"
|
|
bip39_12WordsExpectedMnemonic = "girl mad pet galaxy egg matter matrix prison refuse sense ordinary nose"
|
|
|
|
// BIP39 18 English words test vector
|
|
bip39_18WordsPath = "m/83696968'/39'/0'/18'/0'"
|
|
bip39_18WordsExpectedEntropy = "938033ed8b12698449d4bbca3c853c66b293ea1b1ce9d9dc"
|
|
bip39_18WordsExpectedMnemonic = "near account window bike charge season chef number sketch tomorrow excuse sniff circle vital hockey outdoor supply token"
|
|
|
|
// BIP39 24 English words test vector
|
|
bip39_24WordsPath = "m/83696968'/39'/0'/24'/0'"
|
|
bip39_24WordsExpectedEntropy = "ae131e2312cdc61331542efe0d1077bac5ea803adf24b313a4f0e48e9c51f37f"
|
|
bip39_24WordsExpectedMnemonic = "puppy ocean match cereal symbol another shed magic wrap hammer bulb intact gadget divorce twin tonight reason outdoor destroy simple truth cigar social volcano"
|
|
|
|
// HD-Seed WIF test vector
|
|
hdWifPath = "m/83696968'/2'/0'"
|
|
hdWifExpectedEntropy = "7040bb53104f27367f317558e78a994ada7296c6fde36a364e5baf206e502bb1"
|
|
hdWifExpectedWIF = "Kzyv4uF39d4Jrw2W7UryTHwZr1zQVNk4dAFyqE6BuMrMh1Za7uhp"
|
|
|
|
// XPRV test vector
|
|
xprvPath = "m/83696968'/32'/0'"
|
|
xprvExpectedKey = "xprv9s21ZrQH143K2srSbCSg4m4kLvPMzcWydgmKEnMmoZUurYuBuYG46c6P71UGXMzmriLzCCBvKQWBUv3vPB3m1SATMhp3uEjXHJ42jFg7myX"
|
|
|
|
// HEX test vector
|
|
hexPath = "m/83696968'/128169'/64'/0'"
|
|
hexExpectedEntropy = "492db4698cf3b73a5a24998aa3e9d7fa96275d85724a91e71aa2d645442f878555d078fd1f1f67e368976f04137b1f7a0d19232136ca50c44614af72b5582a5c"
|
|
|
|
// PWD Base64 test vector
|
|
pwdBase64Path = "m/83696968'/707764'/21'/0'"
|
|
pwdBase64ExpectedEntropy = "74a2e87a9ba0cdd549bdd2f9ea880d554c6c355b08ed25088cfa88f3f1c4f74632b652fd4a8f5fda43074c6f6964a3753b08bb5210c8f5e75c07a4c2a20bf6e9"
|
|
pwdBase64ExpectedPassword = "dKLoepugzdVJvdL56ogNV"
|
|
|
|
// PWD Base85 test vector
|
|
pwdBase85Path = "m/83696968'/707785'/12'/0'"
|
|
pwdBase85ExpectedEntropy = "f7cfe56f63dca2490f65fcbf9ee63dcd85d18f751b6b5e1c1b8733af6459c904a75e82b4a22efff9b9e69de2144b293aa8714319a054b6cb55826a8e51425209"
|
|
pwdBase85ExpectedPassword = "_s`{TW89)i4`"
|
|
|
|
// Test keys for parsing tests
|
|
testInvalidMasterKey = "xprv9s21ZrQH143K2LBWUUQRFXhucrQqBpKdRRxNVq2zBqsx8HVqFk2uYo8kmbaLLHRdqtQpUm98uKfu3vca1LqdGhUtyoFnCNkfmXRyPXLjbXX"
|
|
testTestnetMasterKey = "tprv8ZgxMBicQKsPeWHBt7a68nPnvgTnuDhUgDWC8wZCgA8GahrQ3f3uWpq7wE7Uc1dLBnCe1hhCZ886K6ND37memRDWqsA9HgSKDXtwh2Qxo6J"
|
|
)
|
|
|
|
// logTestVector logs test information in a cleaner, more concise format
|
|
func logTestVector(t *testing.T, title, description string) {
|
|
t.Logf("=== TEST: %s ===", title)
|
|
}
|
|
|
|
// TestDerivedKey is a helper function to test the derived key directly
|
|
func TestDerivedKey(t *testing.T) {
|
|
logTestVector(t, "Derived Child Keys", "Testing direct key derivation for BIP85 paths")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Test case 1
|
|
t.Logf("Deriving key for path: %s", testCase1Path)
|
|
derivedKeyBytes, err := DeriveChildKey(masterKey, testCase1Path)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive child key: %v", err)
|
|
}
|
|
|
|
derivedKeyHex := hex.EncodeToString(derivedKeyBytes)
|
|
t.Logf("EXPECTED: %s", testCase1ExpectedDerivedKey)
|
|
t.Logf("ACTUAL: %s", derivedKeyHex)
|
|
|
|
if derivedKeyHex != testCase1ExpectedDerivedKey {
|
|
t.Errorf("Expected derived key bytes %s, got %s", testCase1ExpectedDerivedKey, derivedKeyHex)
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
|
|
// Test case 2
|
|
t.Logf("Deriving key for path: %s", testCase2Path)
|
|
derivedKeyBytes, err = DeriveChildKey(masterKey, testCase2Path)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive child key: %v", err)
|
|
}
|
|
|
|
derivedKeyHex = hex.EncodeToString(derivedKeyBytes)
|
|
t.Logf("EXPECTED: %s", testCase2ExpectedDerivedKey)
|
|
t.Logf("ACTUAL: %s", derivedKeyHex)
|
|
|
|
if derivedKeyHex != testCase2ExpectedDerivedKey {
|
|
t.Errorf("Expected derived key bytes %s, got %s", testCase2ExpectedDerivedKey, derivedKeyHex)
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
}
|
|
|
|
// TestCase1 tests the first test vector from the BIP85 specification
|
|
func TestCase1(t *testing.T) {
|
|
logTestVector(t, "Test Case 1", "Basic entropy derivation with path m/83696968'/0'/0'")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
t.Logf("Test path: %s", testCase1Path)
|
|
entropy, err := DeriveBIP85Entropy(masterKey, testCase1Path)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
derivedEntropyHex := hex.EncodeToString(entropy)
|
|
t.Logf("EXPECTED: %s", testCase1ExpectedEntropy)
|
|
t.Logf("ACTUAL: %s", derivedEntropyHex)
|
|
|
|
if derivedEntropyHex != testCase1ExpectedEntropy {
|
|
t.Errorf("Expected derived entropy %s, got %s", testCase1ExpectedEntropy, derivedEntropyHex)
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
}
|
|
|
|
// TestCase2 tests the second test vector from the BIP85 specification
|
|
func TestCase2(t *testing.T) {
|
|
logTestVector(t, "Test Case 2", "Basic entropy derivation with path m/83696968'/0'/1'")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
t.Logf("Test path: %s", testCase2Path)
|
|
entropy, err := DeriveBIP85Entropy(masterKey, testCase2Path)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
derivedEntropyHex := hex.EncodeToString(entropy)
|
|
t.Logf("EXPECTED: %s", testCase2ExpectedEntropy)
|
|
t.Logf("ACTUAL: %s", derivedEntropyHex)
|
|
|
|
if derivedEntropyHex != testCase2ExpectedEntropy {
|
|
t.Errorf("Expected derived entropy %s, got %s", testCase2ExpectedEntropy, derivedEntropyHex)
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
}
|
|
|
|
// TestBIP39_12EnglishWords tests the BIP39 12 English words test vector
|
|
func TestBIP39_12EnglishWords(t *testing.T) {
|
|
logTestVector(t, "BIP39 12 English Words", "Deriving a 12-word English BIP39 mnemonic")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
t.Logf("Path: %s", bip39_12WordsPath)
|
|
t.Logf("Parameters: Language=English(0), Words=12, Index=0")
|
|
|
|
// BIP39 English 12 word mnemonic
|
|
entropy, err := DeriveBIP39Entropy(masterKey, 0, 12, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive BIP39 entropy: %v", err)
|
|
}
|
|
|
|
derivedEntropyHex := hex.EncodeToString(entropy)
|
|
t.Logf("EXPECTED ENTROPY: %s", bip39_12WordsExpectedEntropy)
|
|
t.Logf("ACTUAL ENTROPY: %s", derivedEntropyHex)
|
|
|
|
if derivedEntropyHex != bip39_12WordsExpectedEntropy {
|
|
t.Errorf("Expected derived entropy %s, got %s", bip39_12WordsExpectedEntropy, derivedEntropyHex)
|
|
} else {
|
|
t.Logf("ENTROPY MATCH: PASS ✓")
|
|
}
|
|
|
|
// Convert entropy to mnemonic
|
|
mnemonic, err := bip39.NewMnemonic(entropy)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create mnemonic: %v", err)
|
|
}
|
|
|
|
t.Logf("EXPECTED MNEMONIC: %s", bip39_12WordsExpectedMnemonic)
|
|
t.Logf("ACTUAL MNEMONIC: %s", mnemonic)
|
|
|
|
if mnemonic != bip39_12WordsExpectedMnemonic {
|
|
t.Errorf("Expected mnemonic '%s', got '%s'", bip39_12WordsExpectedMnemonic, mnemonic)
|
|
} else {
|
|
t.Logf("MNEMONIC MATCH: PASS ✓")
|
|
}
|
|
}
|
|
|
|
// TestBIP39_18EnglishWords tests the BIP39 18 English words test vector
|
|
func TestBIP39_18EnglishWords(t *testing.T) {
|
|
logTestVector(t, "BIP39 18 English Words", "Deriving an 18-word English BIP39 mnemonic")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
t.Logf("Path: %s", bip39_18WordsPath)
|
|
t.Logf("Parameters: Language=English(0), Words=18, Index=0")
|
|
|
|
// BIP39 English 18 word mnemonic
|
|
entropy, err := DeriveBIP39Entropy(masterKey, 0, 18, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive BIP39 entropy: %v", err)
|
|
}
|
|
|
|
derivedEntropyHex := hex.EncodeToString(entropy)
|
|
t.Logf("EXPECTED ENTROPY: %s", bip39_18WordsExpectedEntropy)
|
|
t.Logf("ACTUAL ENTROPY: %s", derivedEntropyHex)
|
|
|
|
if derivedEntropyHex != bip39_18WordsExpectedEntropy {
|
|
t.Errorf("Expected derived entropy %s, got %s", bip39_18WordsExpectedEntropy, derivedEntropyHex)
|
|
} else {
|
|
t.Logf("ENTROPY MATCH: PASS ✓")
|
|
}
|
|
|
|
// Convert entropy to mnemonic
|
|
mnemonic, err := bip39.NewMnemonic(entropy)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create mnemonic: %v", err)
|
|
}
|
|
|
|
t.Logf("EXPECTED MNEMONIC: %s", bip39_18WordsExpectedMnemonic)
|
|
t.Logf("ACTUAL MNEMONIC: %s", mnemonic)
|
|
|
|
if mnemonic != bip39_18WordsExpectedMnemonic {
|
|
t.Errorf("Expected mnemonic '%s', got '%s'", bip39_18WordsExpectedMnemonic, mnemonic)
|
|
} else {
|
|
t.Logf("MNEMONIC MATCH: PASS ✓")
|
|
}
|
|
}
|
|
|
|
// TestBIP39_24EnglishWords tests the BIP39 24 English words test vector
|
|
func TestBIP39_24EnglishWords(t *testing.T) {
|
|
logTestVector(t, "BIP39 24 English Words", "Deriving a 24-word English BIP39 mnemonic")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
t.Logf("Path: %s", bip39_24WordsPath)
|
|
t.Logf("Parameters: Language=English(0), Words=24, Index=0")
|
|
|
|
// BIP39 English 24 word mnemonic
|
|
entropy, err := DeriveBIP39Entropy(masterKey, 0, 24, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive BIP39 entropy: %v", err)
|
|
}
|
|
|
|
derivedEntropyHex := hex.EncodeToString(entropy)
|
|
t.Logf("EXPECTED ENTROPY: %s", bip39_24WordsExpectedEntropy)
|
|
t.Logf("ACTUAL ENTROPY: %s", derivedEntropyHex)
|
|
|
|
if derivedEntropyHex != bip39_24WordsExpectedEntropy {
|
|
t.Errorf("Expected derived entropy %s, got %s", bip39_24WordsExpectedEntropy, derivedEntropyHex)
|
|
} else {
|
|
t.Logf("ENTROPY MATCH: PASS ✓")
|
|
}
|
|
|
|
// Convert entropy to mnemonic
|
|
mnemonic, err := bip39.NewMnemonic(entropy)
|
|
if err != nil {
|
|
t.Fatalf("Failed to create mnemonic: %v", err)
|
|
}
|
|
|
|
t.Logf("EXPECTED MNEMONIC: %s", bip39_24WordsExpectedMnemonic)
|
|
t.Logf("ACTUAL MNEMONIC: %s", mnemonic)
|
|
|
|
if mnemonic != bip39_24WordsExpectedMnemonic {
|
|
t.Errorf("Expected mnemonic '%s', got '%s'", bip39_24WordsExpectedMnemonic, mnemonic)
|
|
} else {
|
|
t.Logf("MNEMONIC MATCH: PASS ✓")
|
|
}
|
|
}
|
|
|
|
// TestHD_WIF tests the WIF test vector
|
|
func TestHD_WIF(t *testing.T) {
|
|
logTestVector(t, "HD-Seed WIF", "Deriving a WIF-encoded private key for Bitcoin Core hdseed")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// First verify the entropy derivation
|
|
t.Logf("Path: %s", hdWifPath)
|
|
|
|
entropy, err := DeriveBIP85Entropy(masterKey, hdWifPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// Expected entropy from BIP85 spec
|
|
derivedEntropyHex := hex.EncodeToString(entropy[:32]) // WIF uses first 32 bytes
|
|
|
|
if derivedEntropyHex != hdWifExpectedEntropy {
|
|
t.Errorf("Entropy mismatch!\nExpected: %s\nGot: %s", hdWifExpectedEntropy, derivedEntropyHex)
|
|
}
|
|
|
|
// Now test the WIF derivation
|
|
wif, err := DeriveWIFKey(masterKey, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive WIF key: %v", err)
|
|
}
|
|
|
|
t.Logf("EXPECTED WIF: %s", hdWifExpectedWIF)
|
|
t.Logf("ACTUAL WIF: %s", wif)
|
|
|
|
if wif != hdWifExpectedWIF {
|
|
t.Errorf("Expected WIF %s, got %s", hdWifExpectedWIF, wif)
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
}
|
|
|
|
// TestXPRV tests the XPRV test vector
|
|
func TestXPRV(t *testing.T) {
|
|
logTestVector(t, "XPRV", "Deriving an extended private key (XPRV)")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
t.Logf("Path: %s", xprvPath)
|
|
derivedKey, err := DeriveXPRV(masterKey, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive XPRV: %v", err)
|
|
}
|
|
|
|
derivedXPRV := derivedKey.String()
|
|
t.Logf("EXPECTED XPRV: %s", xprvExpectedKey)
|
|
t.Logf("ACTUAL XPRV: %s", derivedXPRV)
|
|
|
|
if derivedXPRV != xprvExpectedKey {
|
|
t.Errorf("Expected XPRV %s, got %s", xprvExpectedKey, derivedXPRV)
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
}
|
|
|
|
// TestDRNG_SHAKE256 tests the BIP85-DRNG-SHAKE256 test vector
|
|
func TestDRNG_SHAKE256(t *testing.T) {
|
|
logTestVector(t, "DRNG-SHAKE256", "Testing the deterministic random number generator with SHAKE256")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Derive entropy for the DRNG
|
|
entropy, err := DeriveBIP85Entropy(masterKey, drngTestPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// Create DRNG
|
|
drng := NewBIP85DRNG(entropy)
|
|
|
|
// Read 80 bytes
|
|
buffer := make([]byte, 80)
|
|
n, err := drng.Read(buffer)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from DRNG: %v", err)
|
|
}
|
|
if n != 80 {
|
|
t.Errorf("Expected to read 80 bytes, got %d", n)
|
|
}
|
|
|
|
hexOutput := hex.EncodeToString(buffer)
|
|
|
|
if !strings.EqualFold(hexOutput, drngExpected80Bytes) {
|
|
t.Errorf("Expected DRNG output:\n%s\n\nGot:\n%s", drngExpected80Bytes, hexOutput)
|
|
}
|
|
}
|
|
|
|
// TestPythonDRNGVectors tests the DRNG vectors from the Python implementation
|
|
func TestPythonDRNGVectors(t *testing.T) {
|
|
logTestVector(t, "Python DRNG Vectors", "Testing specific DRNG vectors from the Python implementation")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Derive entropy for the DRNG
|
|
entropy, err := DeriveBIP85Entropy(masterKey, drngTestPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// Create DRNG
|
|
drng := NewBIP85DRNG(entropy)
|
|
|
|
// Test vector 1: Read 50 bytes
|
|
buffer1 := make([]byte, 50)
|
|
_, err = drng.Read(buffer1)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read 50 bytes from DRNG: %v", err)
|
|
}
|
|
actual1 := hex.EncodeToString(buffer1)
|
|
if actual1 != pythonDRNG50BytesExpected {
|
|
t.Errorf("Test vector 1 failed. Expected:\n%s\n\nGot:\n%s", pythonDRNG50BytesExpected, actual1)
|
|
}
|
|
|
|
// Test vector 2: Read 100 bytes
|
|
buffer2 := make([]byte, 100)
|
|
_, err = drng.Read(buffer2)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read 100 bytes from DRNG: %v", err)
|
|
}
|
|
actual2 := hex.EncodeToString(buffer2)
|
|
if actual2 != pythonDRNG100BytesExpected {
|
|
t.Errorf("Test vector 2 failed. Expected:\n%s\n\nGot:\n%s", pythonDRNG100BytesExpected, actual2)
|
|
}
|
|
|
|
// Test vector 3: Read 150 bytes
|
|
buffer3 := make([]byte, 150)
|
|
_, err = drng.Read(buffer3)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read 150 bytes from DRNG: %v", err)
|
|
}
|
|
actual3 := hex.EncodeToString(buffer3)
|
|
if actual3 != pythonDRNG150BytesExpected {
|
|
t.Errorf("Test vector 3 failed. Expected:\n%s\n\nGot:\n%s", pythonDRNG150BytesExpected, actual3)
|
|
}
|
|
|
|
// Test with fresh DRNG
|
|
drng2 := NewBIP85DRNG(entropy)
|
|
buffer4 := make([]byte, 20)
|
|
_, err = drng2.Read(buffer4)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read 20 bytes from DRNG: %v", err)
|
|
}
|
|
actual4 := hex.EncodeToString(buffer4)
|
|
if actual4 != pythonDRNG20BytesExpected {
|
|
t.Errorf("Test vector 4 failed. Expected:\n%s\n\nGot:\n%s", pythonDRNG20BytesExpected, actual4)
|
|
}
|
|
|
|
// Read another 25 bytes
|
|
buffer5 := make([]byte, 25)
|
|
_, err = drng2.Read(buffer5)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read 25 bytes from DRNG: %v", err)
|
|
}
|
|
actual5 := hex.EncodeToString(buffer5)
|
|
if actual5 != pythonDRNG25BytesExpected {
|
|
t.Errorf("Test vector 5 failed. Expected:\n%s\n\nGot:\n%s", pythonDRNG25BytesExpected, actual5)
|
|
}
|
|
}
|
|
|
|
// TestDRNGDeterminism tests the deterministic behavior of the DRNG
|
|
func TestDRNGDeterminism(t *testing.T) {
|
|
logTestVector(t, "DRNG Determinism", "Testing deterministic behavior of the DRNG")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Derive entropy for the DRNG
|
|
entropy, err := DeriveBIP85Entropy(masterKey, drngTestPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// Create 3 DRNGs with the same seed
|
|
drng1 := NewBIP85DRNG(entropy)
|
|
drng2 := NewBIP85DRNG(entropy)
|
|
drng3 := NewBIP85DRNG(entropy)
|
|
|
|
// Read from drng1 with multiple calls
|
|
buf1a := make([]byte, 10)
|
|
buf1b := make([]byte, 20)
|
|
buf1c := make([]byte, 30)
|
|
buf1d := make([]byte, 40)
|
|
_, err = drng1.Read(buf1a)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from drng1: %v", err)
|
|
}
|
|
_, err = drng1.Read(buf1b)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from drng1: %v", err)
|
|
}
|
|
_, err = drng1.Read(buf1c)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from drng1: %v", err)
|
|
}
|
|
_, err = drng1.Read(buf1d)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from drng1: %v", err)
|
|
}
|
|
|
|
// Read from drng2 with multiple calls in different order
|
|
buf2a := make([]byte, 40)
|
|
buf2b := make([]byte, 30)
|
|
buf2c := make([]byte, 20)
|
|
buf2d := make([]byte, 10)
|
|
_, err = drng2.Read(buf2a)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from drng2: %v", err)
|
|
}
|
|
_, err = drng2.Read(buf2b)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from drng2: %v", err)
|
|
}
|
|
_, err = drng2.Read(buf2c)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from drng2: %v", err)
|
|
}
|
|
_, err = drng2.Read(buf2d)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from drng2: %v", err)
|
|
}
|
|
|
|
// Read from drng3 with a single call
|
|
buf3 := make([]byte, 100)
|
|
_, err = drng3.Read(buf3)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from drng3: %v", err)
|
|
}
|
|
|
|
// Combine the results from the multiple reads
|
|
result1 := append(append(append(buf1a, buf1b...), buf1c...), buf1d...)
|
|
result2 := append(append(append(buf2a, buf2b...), buf2c...), buf2d...)
|
|
|
|
// All results should be identical
|
|
if !bytes.Equal(result1, result2) {
|
|
t.Errorf("Expected drng1 and drng2 to produce identical outputs")
|
|
}
|
|
if !bytes.Equal(result2, buf3) {
|
|
t.Errorf("Expected drng2 and drng3 to produce identical outputs")
|
|
}
|
|
}
|
|
|
|
// TestDRNGLengths tests the DRNG with different lengths
|
|
func TestDRNGLengths(t *testing.T) {
|
|
logTestVector(t, "DRNG Lengths", "Testing DRNG with different read lengths")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Derive entropy for the DRNG
|
|
entropy, err := DeriveBIP85Entropy(masterKey, drngTestPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// Create DRNG
|
|
drng := NewBIP85DRNG(entropy)
|
|
|
|
// Test various lengths
|
|
lengths := []int{1, 10, 100, 1000, 10000}
|
|
for _, length := range lengths {
|
|
buffer := make([]byte, length)
|
|
n, err := drng.Read(buffer)
|
|
if err != nil {
|
|
t.Errorf("Failed to read %d bytes: %v", length, err)
|
|
continue
|
|
}
|
|
if n != length {
|
|
t.Errorf("Expected to read %d bytes, got %d", length, n)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestDRNGExceptions tests error handling in the DRNG
|
|
func TestDRNGExceptions(t *testing.T) {
|
|
logTestVector(t, "DRNG Exceptions", "Testing error handling in the DRNG")
|
|
|
|
// Test with entropy of the wrong size
|
|
testCases := []int{0, 1, 32, 63, 65, 128}
|
|
|
|
for _, size := range testCases {
|
|
t.Run(fmt.Sprintf("EntropySize_%d", size), func(t *testing.T) {
|
|
entropy := make([]byte, size)
|
|
|
|
// Use a function to capture the panic
|
|
testPanic := func() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
// Expected behavior - panic occurred
|
|
return
|
|
}
|
|
}()
|
|
|
|
// This should panic for any size != 64
|
|
_ = NewBIP85DRNG(entropy)
|
|
|
|
// If we get here without panic, it's an error
|
|
t.Errorf("Expected panic for entropy length %d, but it didn't happen", size)
|
|
}
|
|
|
|
testPanic()
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestDRNGDifferentSizes tests the DRNG with different buffer sizes
|
|
func TestDRNGDifferentSizes(t *testing.T) {
|
|
logTestVector(t, "DRNG Different Sizes", "Testing the DRNG with different buffer sizes")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
entropy, err := DeriveBIP85Entropy(masterKey, drngTestPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// Create DRNG
|
|
drng := NewBIP85DRNG(entropy)
|
|
|
|
// Test reading different sizes
|
|
for _, size := range []int{32, 64, 128, 256} {
|
|
buffer := make([]byte, size)
|
|
n, err := drng.Read(buffer)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read %d bytes from DRNG: %v", size, err)
|
|
}
|
|
if n != size {
|
|
t.Errorf("Expected to read %d bytes, got %d", size, n)
|
|
}
|
|
}
|
|
|
|
// Test deterministic behavior - two DRNGs with the same seed should produce the same output
|
|
drng1 := NewBIP85DRNG(entropy)
|
|
drng2 := NewBIP85DRNG(entropy)
|
|
|
|
buffer1 := make([]byte, 32)
|
|
buffer2 := make([]byte, 32)
|
|
|
|
_, err = drng1.Read(buffer1)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from first DRNG: %v", err)
|
|
}
|
|
|
|
_, err = drng2.Read(buffer2)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read from second DRNG: %v", err)
|
|
}
|
|
|
|
if !bytes.Equal(buffer1, buffer2) {
|
|
t.Errorf("Expected identical outputs from DRNGs with same seed")
|
|
}
|
|
|
|
// Reading another 32 bytes should produce different output from the first read
|
|
buffer3 := make([]byte, 32)
|
|
_, err = drng1.Read(buffer3)
|
|
if err != nil {
|
|
t.Fatalf("Failed to read second buffer from DRNG: %v", err)
|
|
}
|
|
|
|
if bytes.Equal(buffer1, buffer3) {
|
|
t.Errorf("Expected different outputs from sequential reads")
|
|
}
|
|
}
|
|
|
|
// TestMasterKeyParsing tests parsing of different master key formats
|
|
func TestMasterKeyParsing(t *testing.T) {
|
|
logTestVector(t, "Master Key Parsing", "Testing parsing of master keys in different formats")
|
|
|
|
// Test valid master key
|
|
t.Logf("Testing valid master key")
|
|
_, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Errorf("Failed to parse valid master key: %v", err)
|
|
} else {
|
|
t.Logf("Valid master key parsed successfully: PASS ✓")
|
|
}
|
|
|
|
// Test invalid master key (wrong checksum)
|
|
t.Logf("Testing invalid master key (corrupted)")
|
|
_, err = ParseMasterKey(testInvalidMasterKey)
|
|
if err == nil {
|
|
t.Errorf("Expected error for invalid master key, but got nil")
|
|
} else {
|
|
t.Logf("Got expected error for invalid master key: %v", err)
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
|
|
// Test testnet master key (tprv)
|
|
t.Logf("Testing testnet master key format")
|
|
testnetMasterKey, err := ParseMasterKey(testTestnetMasterKey)
|
|
if err != nil {
|
|
t.Errorf("Failed to parse testnet master key: %v", err)
|
|
} else {
|
|
t.Logf("Testnet master key parsed successfully: PASS ✓")
|
|
|
|
// Test that XPRV derivation using a testnet master key produces a testnet XPRV
|
|
derivedKey, err := DeriveXPRV(testnetMasterKey, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive XPRV from testnet key: %v", err)
|
|
}
|
|
|
|
derivedKeyStr := derivedKey.String()
|
|
if !strings.HasPrefix(derivedKeyStr, "tprv") {
|
|
t.Errorf("Expected derived key to be testnet (tprv prefix), got: %s", derivedKeyStr)
|
|
} else {
|
|
t.Logf("Testnet XPRV derived successfully: %s", derivedKeyStr)
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestDifferentPathFormats tests different path format expressions
|
|
func TestDifferentPathFormats(t *testing.T) {
|
|
logTestVector(t, "Path Formats", "Testing different path format expressions")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Define equivalent paths in different formats
|
|
paths := []string{
|
|
"m/83696968'/0'/0'",
|
|
"m/83696968h/0h/0h",
|
|
"/83696968'/0'/0'",
|
|
"83696968'/0'/0'",
|
|
}
|
|
|
|
var results [][]byte
|
|
|
|
// Derive entropy using each path
|
|
for i, path := range paths {
|
|
t.Logf("Testing path format %d: %s", i+1, path)
|
|
entropy, err := DeriveBIP85Entropy(masterKey, path)
|
|
if err != nil {
|
|
t.Errorf("Failed to derive entropy with path %s: %v", path, err)
|
|
continue
|
|
}
|
|
|
|
results = append(results, entropy)
|
|
t.Logf("Derivation succeeded: PASS ✓")
|
|
}
|
|
|
|
// Verify all results are the same
|
|
for i := 1; i < len(results); i++ {
|
|
if !bytes.Equal(results[0], results[i]) {
|
|
t.Errorf("Path %s produced different entropy than path %s", paths[0], paths[i])
|
|
}
|
|
}
|
|
|
|
if len(results) > 1 {
|
|
t.Logf("All equivalent path formats produced the same entropy: PASS ✓")
|
|
}
|
|
}
|
|
|
|
// TestDirectBase85Encoding tests direct Base85 encoding with the test vector entropy
|
|
func TestDirectBase85Encoding(t *testing.T) {
|
|
logTestVector(t, "Direct Base85 Encoding", "Testing Base85 encoding with BIP85 test vector")
|
|
|
|
// Parse the master key
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// First, derive the entropy and verify it matches the test vector
|
|
derivedEntropy, err := DeriveBIP85Entropy(masterKey, pwdBase85Path)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// This is the expected entropy from the BIP85 spec for the Base85 test vector
|
|
expectedEntropy, err := hex.DecodeString(pwdBase85ExpectedEntropy)
|
|
if err != nil {
|
|
t.Fatalf("Failed to decode expected entropy hex: %v", err)
|
|
}
|
|
|
|
// Verify the derived entropy matches the expected entropy
|
|
derivedEntropyHex := hex.EncodeToString(derivedEntropy)
|
|
if derivedEntropyHex != pwdBase85ExpectedEntropy {
|
|
t.Errorf("Entropy mismatch!\nExpected: %s\nGot: %s", pwdBase85ExpectedEntropy, derivedEntropyHex)
|
|
}
|
|
|
|
// Verify the entropy bytes match
|
|
if !bytes.Equal(derivedEntropy, expectedEntropy) {
|
|
t.Errorf("Entropy bytes do not match the test vector")
|
|
}
|
|
|
|
// Now test the password generation
|
|
pwd, err := DeriveBase85Password(masterKey, 12, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive Base85 password: %v", err)
|
|
}
|
|
|
|
// Expected password from the test vector
|
|
if pwd != pwdBase85ExpectedPassword {
|
|
t.Errorf("Password mismatch!\nExpected: '%s'\nGot: '%s'", pwdBase85ExpectedPassword, pwd)
|
|
}
|
|
}
|
|
|
|
// TestPWDBase64 tests the Base64 password test vector
|
|
func TestPWDBase64(t *testing.T) {
|
|
logTestVector(t, "PWD Base64", "Deriving a Base64-encoded password")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Testing with the example from the BIP85 spec - 21 characters
|
|
t.Logf("Path: %s", pwdBase64Path)
|
|
t.Logf("Parameters: Length=21, Index=0")
|
|
|
|
// First verify the entropy derivation
|
|
entropy, err := DeriveBIP85Entropy(masterKey, pwdBase64Path)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// Expected entropy from BIP85 spec
|
|
derivedEntropyHex := hex.EncodeToString(entropy)
|
|
|
|
if derivedEntropyHex != pwdBase64ExpectedEntropy {
|
|
t.Errorf("Entropy mismatch!\nExpected: %s\nGot: %s", pwdBase64ExpectedEntropy, derivedEntropyHex)
|
|
}
|
|
|
|
// Now test the password generation
|
|
pwd, err := DeriveBase64Password(masterKey, 21, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive Base64 password: %v", err)
|
|
}
|
|
|
|
// The test vector from the BIP85 specification
|
|
t.Logf("EXPECTED PASSWORD: %s", pwdBase64ExpectedPassword)
|
|
t.Logf("ACTUAL PASSWORD: %s", pwd)
|
|
|
|
if pwd != pwdBase64ExpectedPassword {
|
|
t.Errorf("Expected password '%s', got '%s'", pwdBase64ExpectedPassword, pwd)
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
|
|
t.Logf("Password length: %d characters", len(pwd))
|
|
}
|
|
|
|
// TestPWDBase85 tests the Base85 password test vector
|
|
func TestPWDBase85(t *testing.T) {
|
|
logTestVector(t, "PWD Base85", "Deriving a Base85-encoded password")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Testing with the example from the BIP85 spec - 12 characters
|
|
t.Logf("Path: %s", pwdBase85Path)
|
|
t.Logf("Parameters: Length=12, Index=0")
|
|
|
|
// First verify the entropy derivation
|
|
entropy, err := DeriveBIP85Entropy(masterKey, pwdBase85Path)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// Expected entropy from BIP85 spec
|
|
derivedEntropyHex := hex.EncodeToString(entropy)
|
|
|
|
if derivedEntropyHex != pwdBase85ExpectedEntropy {
|
|
t.Errorf("Entropy mismatch!\nExpected: %s\nGot: %s", pwdBase85ExpectedEntropy, derivedEntropyHex)
|
|
}
|
|
|
|
// Now test the password generation
|
|
pwd, err := DeriveBase85Password(masterKey, 12, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive Base85 password: %v", err)
|
|
}
|
|
|
|
// The test vector from the BIP85 specification
|
|
t.Logf("EXPECTED PASSWORD: %s", pwdBase85ExpectedPassword)
|
|
t.Logf("ACTUAL PASSWORD: %s", pwd)
|
|
|
|
if pwd != pwdBase85ExpectedPassword {
|
|
t.Errorf("Expected password '%s', got '%s'", pwdBase85ExpectedPassword, pwd)
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
|
|
t.Logf("Password length: %d characters", len(pwd))
|
|
}
|
|
|
|
// TestHexDerivation tests the HEX derivation test vector
|
|
func TestHexDerivation(t *testing.T) {
|
|
logTestVector(t, "HEX Derivation", "Testing HEX data derivation with BIP85 test vector")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Test vector from BIP85 spec
|
|
t.Logf("Path: %s", hexPath)
|
|
t.Logf("Parameters: NumBytes=64, Index=0")
|
|
|
|
// First verify the entropy derivation
|
|
entropy, err := DeriveBIP85Entropy(masterKey, hexPath)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive entropy: %v", err)
|
|
}
|
|
|
|
// Expected entropy from BIP85 spec
|
|
derivedEntropyHex := hex.EncodeToString(entropy[:64]) // HEX uses first 64 bytes
|
|
|
|
if derivedEntropyHex != hexExpectedEntropy {
|
|
t.Errorf("Entropy mismatch!\nExpected: %s\nGot: %s", hexExpectedEntropy, derivedEntropyHex)
|
|
}
|
|
|
|
// Now test the hex derivation
|
|
hexData, err := DeriveHex(masterKey, 64, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive hex data: %v", err)
|
|
}
|
|
|
|
if hexData != hexExpectedEntropy {
|
|
t.Errorf("Hex data mismatch!\nExpected: %s\nGot: %s", hexExpectedEntropy, hexData)
|
|
}
|
|
}
|
|
|
|
// TestInvalidParameters tests error conditions for parameter validation
|
|
func TestInvalidParameters(t *testing.T) {
|
|
logTestVector(t, "Invalid Parameters", "Testing error handling for invalid inputs")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Test cases for parameter validation
|
|
testCases := []struct {
|
|
name string
|
|
testFunc func() error
|
|
}{
|
|
{
|
|
name: "BIP39 invalid word count",
|
|
testFunc: func() error {
|
|
_, err := DeriveBIP39Entropy(masterKey, 0, 13, 0) // 13 is not valid (must be 12, 15, 18, 21, 24)
|
|
return err
|
|
},
|
|
},
|
|
{
|
|
name: "Base64 password too short",
|
|
testFunc: func() error {
|
|
_, err := DeriveBase64Password(masterKey, 19, 0) // Min is 20
|
|
return err
|
|
},
|
|
},
|
|
{
|
|
name: "Base64 password too long",
|
|
testFunc: func() error {
|
|
_, err := DeriveBase64Password(masterKey, 87, 0) // Max is 86
|
|
return err
|
|
},
|
|
},
|
|
{
|
|
name: "Base85 password too short",
|
|
testFunc: func() error {
|
|
_, err := DeriveBase85Password(masterKey, 9, 0) // Min is 10
|
|
return err
|
|
},
|
|
},
|
|
{
|
|
name: "Base85 password too long",
|
|
testFunc: func() error {
|
|
_, err := DeriveBase85Password(masterKey, 81, 0) // Max is 80
|
|
return err
|
|
},
|
|
},
|
|
{
|
|
name: "Hex data too small",
|
|
testFunc: func() error {
|
|
_, err := DeriveHex(masterKey, 15, 0) // Min is 16
|
|
return err
|
|
},
|
|
},
|
|
{
|
|
name: "Hex data too large",
|
|
testFunc: func() error {
|
|
_, err := DeriveHex(masterKey, 65, 0) // Max is 64
|
|
return err
|
|
},
|
|
},
|
|
}
|
|
|
|
// Run all validation test cases
|
|
for _, tc := range testCases {
|
|
t.Logf("Testing: %s", tc.name)
|
|
err := tc.testFunc()
|
|
if err == nil {
|
|
t.Errorf("Expected error for %s, but got nil", tc.name)
|
|
} else {
|
|
t.Logf("Got expected error: %v", err)
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestAdditionalDeriveHex tests additional hex derivation scenarios
|
|
func TestAdditionalDeriveHex(t *testing.T) {
|
|
logTestVector(t, "Additional Hex Derivation", "Testing hex data derivation with various lengths")
|
|
|
|
masterKey, err := ParseMasterKey(testMasterKey)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse master key: %v", err)
|
|
}
|
|
|
|
// Test min size (16 bytes)
|
|
hexMinBytes, err := DeriveHex(masterKey, 16, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive 16-byte hex: %v", err)
|
|
}
|
|
t.Logf("16-byte hex: %s", hexMinBytes)
|
|
if len(hexMinBytes) != 32 { // 16 bytes = 32 hex chars
|
|
t.Errorf("Expected 32 hex chars (16 bytes), got %d chars", len(hexMinBytes))
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
|
|
// Test max size (64 bytes)
|
|
hexMaxBytes, err := DeriveHex(masterKey, 64, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive 64-byte hex: %v", err)
|
|
}
|
|
t.Logf("64-byte hex: %s", hexMaxBytes)
|
|
if len(hexMaxBytes) != 128 { // 64 bytes = 128 hex chars
|
|
t.Errorf("Expected 128 hex chars (64 bytes), got %d chars", len(hexMaxBytes))
|
|
} else {
|
|
t.Logf("RESULT: PASS ✓")
|
|
}
|
|
|
|
// Test different index values
|
|
hex1, err := DeriveHex(masterKey, 32, 0)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive hex with index 0: %v", err)
|
|
}
|
|
|
|
hex2, err := DeriveHex(masterKey, 32, 1)
|
|
if err != nil {
|
|
t.Fatalf("Failed to derive hex with index 1: %v", err)
|
|
}
|
|
|
|
t.Logf("Hex index 0: %s", hex1)
|
|
t.Logf("Hex index 1: %s", hex2)
|
|
|
|
if hex1 == hex2 {
|
|
t.Errorf("Expected different hex values for different indexes")
|
|
} else {
|
|
t.Logf("Different indexes produced different outputs: PASS ✓")
|
|
}
|
|
}
|