Hypothetical encryption technique, is it secure? This to me, sounds like a great idea, but with all rosy-tinted ideas it needs some grounding in reality. Here are the steps of the hypothetical system (with the hypothetical part highlighted):

User runs program to encrypt a file.

Prompts for user password.

Hypothetical part (is it secure?):


Program has a list of encryption techniques stored (assume the techniques are publicly known: they can be any level of complexity but how they encrypt is known) and their decryption counterparts.
Each symbol in the password selects a different technique (assume what symbol picks which technique are known: it can be changed but the changes are publicly known).
The program progresses through each symbol in the password encrypting the file with a different algorithm at each stage.
Each encryption technique can take one or all values from the password: the sum of symbols up to the current position (in the password), the sum of the entire password, and the position. These are used to modify the internal encryption process (the sum up to current position used as part of a modulus, for example). Which means if the letter is in the wrong place, it won't decrypt correctly.


Am I correct in assuming that:


A longer password adds more layers of encryption in this hypothetical scenario and thus adds more security and thus encourages longer passwords (a double positive trait)?
Even with the encryption algorithms known, because the password determines what order it's encrypted in, and how many layers, an attacker cannot guess how it was encrypted besides obtaining the password?
That no file (assuming each password is different) will be encrypted the same way twice?
The password is the only major vulnerability?


In short, is it secure?

Are there any flaws people could see with this idea?
First, I would like to point you to this answer. Copying the TL;DR from there:


  Multiple encryption addresses a problem that mostly doesn't exist.


You are better off using a single well chosen algorithm.



That said, here are answers to some of your questions:


  A longer password adds more layers of encryption in this hypothetical scenario and thus adds more security and thus encourages longer passwords (a double positive trait)?


It is not generally true that more layers equals better encryption (cf.  Cascade Ciphers: The Importance of Being First). In particular, in those cases where it can be proved that it is as strong as even one of the layers it is assumed that the keys are independent. Your keys are clearly not independent.


  That no file (assuming each password is different) will be encrypted the same way twice?


If by "same way" you mean into the same ciphertext, then that is already the case with any secure encryption algorithm (with high probability). If you mean with the same cascade, then probably so, if you have as many techniques as different symbols. I.e. a-zA-Z etc. all give a different algorithm. Otherwise some passwords that differ will still lead to the same cascade.


  The password is the only major vulnerability?


No, the algorithms can also leak information about the password through e.g. implementation mistakes or even weaknesses in the algorithm. And the more algorithms you implement, the higher the chances one of them is buggy. As an example of such a mistake:


  The program progresses through each symbol in the password encrypting the file with a different algorithm at each stage.


This is probably almost impossible to implement without timing attacks, so in any situation where the attacker would be able to observe how long it takes to encrypt/decrypt something, they could learn things about the password, narrowing down a brute force or dictionary attack even if they are unable to recover the whole password.



If you nonetheless wish to use more than one algorithm to guard against breaks, I recommend:


Use just two, always. That is simple enough to limit issues and the chance that both are broken should be small with modern well vetted algorithms.
Use stream ciphers (or block ciphers in CTR mode). Their cascade is provably as strong as the stronger if the keys are independent.
Use independent keys that you derive from the password using a strong password hash.
Add authentication.


For example, you could use AES-GCM(ChaCha20(m)), with keys derived using scrypt.