Why not the one-time pad with pseudo-number generator I am very new to cryptography (so be kind), but I have a question that may seem silly. 

If the one-time pad is the perfect cipher and impossible to crack, why would the following algorithm not be one of the strongest:

To encrypt:


generate a random bit array using a pseudo number generator with the key as the seed 
The generated bit array is the size of the data
use a simple XOR to encrypt using the generated bit array


To decrypt:


pseudo-random number generator will generate the same bit array with the same seed (the key)
generate bit array the same size of the encrypted data
run XOR on encrypted data using bit array that's generated


This is very simplified, but you can imagine how for larger encryption you could break down the data into blocks, and in order to ensure that the block bit arrays are random a new seed for each can be derived from the key. So, if $f(k)$ is the pseudo random number generator, and b is the block number, you can encrypt each block with $f(k+b)$. ($k$ is key) 

Instead of using a pseudo-random number generator, you could use some hash algorithm to generate the pad. 

Ceteris paribus (assuming you can use equivalently strong keys) would this not be a very strong cipher method? Perhaps it may be strong and heavy on memory since the pad needs to be the size of the data. So during encryption and decryption you need to generate a pad that's equivalent to the size of the data. 

Is there a flaw in this algorithm, or would something like this not be practical and much slower than current standards?
It's a good question. As pg1989 said, this is the basis behind stream ciphers, which are very fast in practice.

I thought I'd quickly expand upon your statement that "the one-time pad is the perfect cipher and impossible to crack." This is true, in a sense, but it's worth pointing out that sometimes an attacker wants to do something simpler than "cracking" the encryption scheme in order to recover all plaintexts.

For instance, an attacker may just want to change the message so that the honest recipient decrypts something else. As a simple example, suppose that the attacker knew for sure that the message was either "yes" or "no!" and just wants to change the message to the other value. Note that:


This is simple to do for messages encrypted using a one-time pad. The linked Wikipedia page describes why this is true, but it's probably more fun to figure it out for yourself.
The attacker can do this without learning the plaintext. Hence, the original claim of a one-time pad being uncrackable is still true.


There are some other issues with a one-time pad construction too, such as the fact that usually some state will be required to make sure that you don't re-use the seed during the next encryption. Hence, while your question is definitely not silly, and stream ciphers are very useful in certain circumstances, they also have their limits.