diff --git a/go.mod b/go.mod
index f5bc73bfc..0e35a2d84 100644
--- a/go.mod
+++ b/go.mod
@@ -5,7 +5,7 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/urfave/cli v1.22.15
 	github.com/xtaci/kcp-go/v5 v5.6.8
-	github.com/xtaci/qpp v1.1.1
+	github.com/xtaci/qpp v1.1.2
 	github.com/xtaci/smux v1.5.24
 	github.com/xtaci/tcpraw v1.2.25
 	golang.org/x/crypto v0.24.0
diff --git a/go.sum b/go.sum
index 5fb2fe0fd..8dc8db33a 100644
--- a/go.sum
+++ b/go.sum
@@ -75,6 +75,8 @@ github.com/xtaci/qpp v1.1.0 h1:PsIxn2lE2MdbbfNmNeTm1iWKw/k8DI/XkU5brOno5H0=
 github.com/xtaci/qpp v1.1.0/go.mod h1:dJS3usaXNMbWxZSWCAdxz01UgJcz9wXDkd4BccDY/V0=
 github.com/xtaci/qpp v1.1.1 h1:UaZCbcwvKTx+pSXi/fQufXg2R82Gn4VBPs/zjGB9FwA=
 github.com/xtaci/qpp v1.1.1/go.mod h1:dJS3usaXNMbWxZSWCAdxz01UgJcz9wXDkd4BccDY/V0=
+github.com/xtaci/qpp v1.1.2 h1:QDJgYCtZdmKNKZ24uNPLq3cgHnp2irnJJBRtQ0gWZlU=
+github.com/xtaci/qpp v1.1.2/go.mod h1:dJS3usaXNMbWxZSWCAdxz01UgJcz9wXDkd4BccDY/V0=
 github.com/xtaci/smux v1.5.24 h1:77emW9dtnOxxOQ5ltR+8BbsX1kzcOxQ5gB+aaV9hXOY=
 github.com/xtaci/smux v1.5.24/go.mod h1:OMlQbT5vcgl2gb49mFkYo6SMf+zP3rcjcwQz7ZU7IGY=
 github.com/xtaci/tcpraw v1.2.25 h1:VDlqo0op17JeXBM6e2G9ocCNLOJcw9mZbobMbJjo0vk=
diff --git a/vendor/github.com/xtaci/qpp/README.md b/vendor/github.com/xtaci/qpp/README.md
index 77e4ed1bc..02057cefc 100644
--- a/vendor/github.com/xtaci/qpp/README.md
+++ b/vendor/github.com/xtaci/qpp/README.md
@@ -36,6 +36,49 @@ The [Quantum Permutation Pad](https://link.springer.com/content/pdf/10.1140/epjq
 - **Future-Proof**: As quantum computers become more powerful, classical cryptographic schemes (like RSA and ECC) are at risk. QPP provides a quantum-resistant alternative.
 - **Secure Communication**: Useful for secure communications in quantum networks and for safeguarding highly sensitive data.
 
+## Examples
+The count of Permutation Matrics in 8-qubit, it's been randomly selected from based on the seed provided.
+<img width="1191" alt="图片" src="https://github.com/xtaci/qpp/assets/2346725/c6112ef6-9f09-4214-bf5c-e8820e39e527">
+
+
+## Usage
+```golang
+Internal PRNG:
+
+func main() {
+    seed := make([]byte, 32)
+    io.ReadFull(rand.Reader, seed)
+
+    qpp := NewQPP(seed, 1024, 8)
+
+    msg := make([]byte, 65536)
+    io.ReadFull(rand.Reader, msg)
+
+    qpp.Encrypt(msg)
+    qpp.Decrypt(msg)
+}
+```
+
+```golang
+External PRNG:
+
+func main() {
+    seed := make([]byte, 32)
+    io.ReadFull(rand.Reader, seed)
+
+    qpp := NewQPP(seed, 1024, 8)
+
+    msg := make([]byte, 65536)
+    io.ReadFull(rand.Reader, msg)
+
+    rand_enc := qpp.CreatePRNG(seed)
+    rand_dec := qpp.CreatePRNG(seed)
+
+    qpp.EncryptWithPRNG(msg, rand_enc)
+    qpp.DecryptWithPRNG(msg, rand_dec)
+}
+```
+
 ## Conclusion
 
 The Quantum Permutation Pad is a promising approach in the field of quantum cryptography, utilizing quantum mechanical properties to achieve secure communication. By applying quantum permutations to encrypt and decrypt data, QPP ensures high security and leverages the unique capabilities of quantum technology. As research and technology in quantum computing and quantum communication advance, protocols like QPP will play a crucial role in the next generation of secure communication systems.
diff --git a/vendor/github.com/xtaci/qpp/qpp.go b/vendor/github.com/xtaci/qpp/qpp.go
index 2c665d9d8..f448ab28a 100644
--- a/vendor/github.com/xtaci/qpp/qpp.go
+++ b/vendor/github.com/xtaci/qpp/qpp.go
@@ -1,6 +1,7 @@
 package qpp
 
 import (
+	"crypto/aes"
 	"crypto/hmac"
 	"crypto/sha1"
 	"crypto/sha256"
@@ -11,23 +12,29 @@ import (
 	"golang.org/x/crypto/pbkdf2"
 )
 
-const PAD_IDENTIFIER = "QPP_%b"
-const PM_SELECTOR_IDENTIFIER = "PERMUTATION_MATRIX_SELECTOR"
-const SHUFFLE_SALT = "___QUANTUM_PERMUTATION_PAD_SHUFFLE_SALT___"
-const PRNG_SALT = "___QUANTUM_PERMUTATION_PAD_PRNG_SALT___"
-const NATIVE_BYTE_LENGTH = 8 // bit
-const PBKDF2_LOOPS = 128
+// Constants used in Quantum Permutation Pad (QPP) for identifiers, salts, and configuration
+const (
+	PAD_IDENTIFIER         = "QPP_%b"
+	PM_SELECTOR_IDENTIFIER = "PERMUTATION_MATRIX_SELECTOR"
+	SHUFFLE_SALT           = "___QUANTUM_PERMUTATION_PAD_SHUFFLE_SALT___"
+	PRNG_SALT              = "___QUANTUM_PERMUTATION_PAD_PRNG_SALT___"
+	NATIVE_BYTE_LENGTH     = 8   // Bit length for native byte
+	PBKDF2_LOOPS           = 128 // Number of iterations for PBKDF2
+)
 
+// QuantumPermutationPad represents the encryption/decryption structure using quantum permutation pads
+// QPP is a cryptographic technique that leverages quantum-inspired permutation matrices to provide secure encryption.
 type QuantumPermutationPad struct {
-	pads  [][]byte // encryption
-	rpads [][]byte // decryption
-
-	numPads uint16     // number of pads
-	qubits  uint8      // number of quantum bits
-	encRand *rand.Rand // random source for pattern selection
-	decRand *rand.Rand // random source for pattern selection
+	pads    [][]byte   // Encryption pads, each pad is a permutation matrix for encryption
+	rpads   [][]byte   // Decryption pads, each pad is a reverse permutation matrix for decryption
+	numPads uint16     // Number of pads (permutation matrices)
+	qubits  uint8      // Number of quantum bits, determines the size of each pad
+	encRand *rand.Rand // Default random source for encryption pad selection
+	decRand *rand.Rand // Default random source for decryption pad selection
 }
 
+// NewQPP creates a new Quantum Permutation Pad instance with the provided seed, number of pads, and qubits
+// The seed is used to generate deterministic pseudo-random number generators (PRNGs) for both encryption and decryption
 func NewQPP(seed []byte, numPads uint16, qubits uint8) *QuantumPermutationPad {
 	qpp := &QuantumPermutationPad{
 		numPads: numPads,
@@ -37,40 +44,43 @@ func NewQPP(seed []byte, numPads uint16, qubits uint8) *QuantumPermutationPad {
 	qpp.pads = make([][]byte, numPads)
 	qpp.rpads = make([][]byte, numPads)
 
+	// Initialize and shuffle pads to create permutation matrices
 	for i := uint16(0); i < numPads; i++ {
 		qpp.pads[i] = make([]byte, 1<<qubits)
 		qpp.rpads[i] = make([]byte, 1<<qubits)
-		fill(qpp.pads[i])
-		shuffle(seed, qpp.pads[i], i)
-		reverse(qpp.pads[i], qpp.rpads[i])
+		fill(qpp.pads[i])                  // Fill pad with sequential byte values
+		shuffle(seed, qpp.pads[i], i)      // Shuffle pad to create a unique permutation matrix
+		reverse(qpp.pads[i], qpp.rpads[i]) // Create the reverse permutation matrix for decryption
 	}
 
-	qpp.encRand = qpp.CreatePRNG(seed)
+	qpp.encRand = qpp.CreatePRNG(seed) // Create default PRNG for encryption
 	qpp.decRand = qpp.CreatePRNG(seed)
 
 	return qpp
 }
 
-// Encrypt encrypts data using the Quantum Permutation Pad with default PRNG
+// Encrypt encrypts the given data using the Quantum Permutation Pad with the default PRNG
+// It selects a permutation matrix based on a random index and uses it to permute each byte of the data
 func (qpp *QuantumPermutationPad) Encrypt(data []byte) {
 	switch qpp.qubits {
 	case NATIVE_BYTE_LENGTH:
 		for i := 0; i < len(data); i++ {
-			rand := qpp.encRand.Uint32()
-			index := rand % uint32(qpp.numPads)
-			pad := qpp.pads[index]
-			data[i] = pad[data[i]^byte(rand&0xFF)]
+			rand := qpp.encRand.Uint32()           // Generate a pseudo-random number
+			index := rand % uint32(qpp.numPads)    // Select a permutation matrix index
+			pad := qpp.pads[index]                 // Retrieve the permutation matrix
+			data[i] = pad[data[i]^byte(rand&0xFF)] // Apply the permutation to the data byte
 		}
 	default:
 	}
 }
 
-// Decrypt decrypts data using the Quantum Permutation Pad with default PRNG
+// Decrypt decrypts the given data using the Quantum Permutation Pad with the default PRNG
+// It selects a reverse permutation matrix based on a random index and uses it to restore each byte of the data
 func (qpp *QuantumPermutationPad) Decrypt(data []byte) {
 	switch qpp.qubits {
 	case NATIVE_BYTE_LENGTH:
 		for i := 0; i < len(data); i++ {
-			rand := qpp.encRand.Uint32()
+			rand := qpp.decRand.Uint32()
 			index := rand % uint32(qpp.numPads)
 			rpad := qpp.rpads[index]
 			data[i] = rpad[data[i]] ^ byte(rand&0xFF)
@@ -79,7 +89,8 @@ func (qpp *QuantumPermutationPad) Decrypt(data []byte) {
 	}
 }
 
-// CreatePRNG creates a deterministic pseudo-random number generator based on seed provided
+// CreatePRNG creates a deterministic pseudo-random number generator based on the provided seed
+// It uses HMAC and PBKDF2 to derive a random seed for the PRNG
 func (qpp *QuantumPermutationPad) CreatePRNG(seed []byte) *rand.Rand {
 	// condense entropy from seed to 8 bytes
 	mac := hmac.New(sha256.New, seed)
@@ -90,9 +101,8 @@ func (qpp *QuantumPermutationPad) CreatePRNG(seed []byte) *rand.Rand {
 	return rand.New(source)
 }
 
-// EncryptWithPRNG encrypts data using the Quantum Permutation Pad with PRNG
-//
-//	this function shares the same P-matrices
+// EncryptWithPRNG encrypts the data using the Quantum Permutation Pad with a custom PRNG
+// This function shares the same permutation matrices
 func (qpp *QuantumPermutationPad) EncryptWithPRNG(data []byte, rand *rand.Rand) {
 	switch qpp.qubits {
 	case NATIVE_BYTE_LENGTH:
@@ -106,9 +116,8 @@ func (qpp *QuantumPermutationPad) EncryptWithPRNG(data []byte, rand *rand.Rand)
 	}
 }
 
-// DecryptWithPRNG decrypts data using the Quantum Permutation Pad with PRNG
-//
-//	this function shares the same P-matrices
+// DecryptWithPRNG decrypts the data using the Quantum Permutation Pad with a custom PRNG
+// This function shares the same permutation matrices
 func (qpp *QuantumPermutationPad) DecryptWithPRNG(data []byte, rand *rand.Rand) {
 	switch qpp.qubits {
 	case NATIVE_BYTE_LENGTH:
@@ -122,28 +131,36 @@ func (qpp *QuantumPermutationPad) DecryptWithPRNG(data []byte, rand *rand.Rand)
 	}
 }
 
+// fill initializes the pad with sequential byte values
+// This sets up a standard permutation matrix before it is shuffled
 func fill(pad []byte) {
 	for i := 0; i < len(pad); i++ {
 		pad[i] = byte(i)
 	}
 }
 
+// reverse generates the reverse permutation pad from the given pad
+// This allows for efficient decryption by reversing the permutation process
 func reverse(pad []byte, rpad []byte) {
 	for i := 0; i < len(pad); i++ {
 		rpad[pad[i]] = byte(i)
 	}
 }
 
+// shuffle shuffles the pad based on the seed and pad identifier to create a permutation matrix
+// It uses HMAC and PBKDF2 to derive a unique shuffle pattern from the seed and pad ID
 func shuffle(seed []byte, pad []byte, padID uint16) {
 	message := fmt.Sprintf(PAD_IDENTIFIER, padID)
 	mac := hmac.New(sha256.New, seed)
 	mac.Write([]byte(message))
 	sum := mac.Sum(nil)
 
-	// condense entropy to 8 bytes
-	dk := pbkdf2.Key(sum, []byte(SHUFFLE_SALT), PBKDF2_LOOPS, 8, sha1.New)
-	source := rand.NewSource(int64(binary.LittleEndian.Uint64(dk)))
-	rand.New(source).Shuffle(len(pad), func(i, j int) {
+	// expand seed to 32-bytes for AES-based PRNG
+	aeskey := pbkdf2.Key(seed, []byte(SHUFFLE_SALT), PBKDF2_LOOPS, 32, sha1.New)
+	block, _ := aes.NewCipher(aeskey)
+	for i := len(pad) - 1; i > 0; i-- {
+		block.Encrypt(sum, sum)
+		j := binary.LittleEndian.Uint64(sum) % uint64(i)
 		pad[i], pad[j] = pad[j], pad[i]
-	})
+	}
 }
diff --git a/vendor/modules.txt b/vendor/modules.txt
index ccdda511b..7a0d09e91 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -38,7 +38,7 @@ github.com/urfave/cli
 # github.com/xtaci/kcp-go/v5 v5.6.8
 ## explicit; go 1.21
 github.com/xtaci/kcp-go/v5
-# github.com/xtaci/qpp v1.1.0
+# github.com/xtaci/qpp v1.1.2
 ## explicit; go 1.22.3
 github.com/xtaci/qpp
 # github.com/xtaci/smux v1.5.24