I understand that [OTP](https://en.wikipedia.org/wiki/One-time_pad) encryption fulfils *perfect secrecy*, meaning you can't decrypt the encrypted text to it's original plaintext (and know that this plaintext is indeed the original plaintext) unless you possess the OTP key.

Let's assume this:

* Alice creates a truly random alphabetical stream of 10 characters (key).
* The key is shared with Bob (we assume that it's secure and no one else can get knowledge of the key)
* Now Alice can encrypt a text with length $\le$ key-length
* Encrypted text is sent to Bob
* Bob can decrypt the encrypted text with the key

---

Now the "new" part:

Alice again wants to sent a message to Bob by using OTP-encryption. But instead of creating a completely new truly random OTP key, **Alice permutes the previously used OTP key.** This permuted key is then used for further OTP encryption/decryption. The permuted key is checked with previous keys to ensure that no encryption happens with an identical key.

We assume that Bob always receives the new (permuted) key over a secure channel and **no one else (ever) knows the key**. We also assume that no one else knows any plaintext messages before/after encryption/decryption.

---

Example of keys:

$k\_1 = \text{gubapqrytt}$ (truly random)

$k\_2 = \text{permute}(k\_1) = \text{ptyaqgtbur}$

$k\_3 = \text{permute}(k\_2) = \ldots$

---

* Does this affect the security of OTP?
* When is the first message vulnerable to decryption by an adversary?
* Do all further keys (if none get leaked) still provide perfect secrecy?

---

EDIT: 

We assume that all keys are kept secret and no keys will be leaked (no matter how unrealistic this might seem). I'm only concerned if this scheme would somehow be vulnerable to any known attacks, like frequency-analysis, since the key has always the same characters.