`  == ``Perfect Security`` ==  Is it really still acceptable to describe one-time-pad as 'perfect security'? Any cryptographic encryption can eventually be broken by a computer, particularly if you are able to validate whether a guessed key was able to decrypt the data successfully or not.  One-time-padding, like all encryption, is ultimately bound by time constraints; a one-time-pad is only ``perfectly`` secure so long as it's only used once, and that the message, if intercepted, is useless beyond the time that it would take to brute-force the encryption, which in itself is a requirement that is subject to chance as computers get faster and faster. For example, no matter how well implemented a one-time-padding scheme is, if it's only being used to encrypt 8-bits of data then pretty much any device with a microchip can decrypt that. It's only really a viable method so long as the data is at least a certain length (which is where, confusingly, padding schemes should almost always be combined with one-time-padding). This length will increase over time as computing power available to an attacker increases as well.  For example, if you used a one time-pad to encrypt a newly issued credit-card number, then I wouldn't consider that secure, as it's relatively easy to match a credit card number to test for success, and the data isn't long enough to prevent it being decrypted within the 3+ years that that card would be valid for. Similarly, the fact that one-time pad exposes the length of the data is also significant, as that could (to continue the example) expose the fact that the data contains, say, five credit card numbers, allowing you to break the data down into five smaller, easier to break pieces.   `