001    package net.minecraft.src;
002    
003    import cpw.mods.fml.common.Side;
004    import cpw.mods.fml.common.asm.SideOnly;
005    import java.io.InputStream;
006    import java.io.OutputStream;
007    import java.io.UnsupportedEncodingException;
008    import java.nio.charset.Charset;
009    import java.security.InvalidKeyException;
010    import java.security.Key;
011    import java.security.KeyFactory;
012    import java.security.KeyPair;
013    import java.security.KeyPairGenerator;
014    import java.security.MessageDigest;
015    import java.security.NoSuchAlgorithmException;
016    import java.security.PrivateKey;
017    import java.security.PublicKey;
018    import java.security.SecureRandom;
019    import java.security.Security;
020    import java.security.spec.InvalidKeySpecException;
021    import java.security.spec.X509EncodedKeySpec;
022    import javax.crypto.BadPaddingException;
023    import javax.crypto.Cipher;
024    import javax.crypto.IllegalBlockSizeException;
025    import javax.crypto.NoSuchPaddingException;
026    import javax.crypto.SecretKey;
027    import javax.crypto.spec.SecretKeySpec;
028    import org.bouncycastle.crypto.BufferedBlockCipher;
029    import org.bouncycastle.crypto.CipherKeyGenerator;
030    import org.bouncycastle.crypto.KeyGenerationParameters;
031    import org.bouncycastle.crypto.engines.AESFastEngine;
032    import org.bouncycastle.crypto.io.CipherInputStream;
033    import org.bouncycastle.crypto.io.CipherOutputStream;
034    import org.bouncycastle.crypto.modes.CFBBlockCipher;
035    import org.bouncycastle.crypto.params.KeyParameter;
036    import org.bouncycastle.crypto.params.ParametersWithIV;
037    import org.bouncycastle.jce.provider.BouncyCastleProvider;
038    
039    public class CryptManager
040    {
041        public static final Charset field_75898_a = Charset.forName("ISO_8859_1");
042    
043        @SideOnly(Side.CLIENT)
044        public static SecretKey func_75890_a()
045        {
046            CipherKeyGenerator var0 = new CipherKeyGenerator();
047            var0.init(new KeyGenerationParameters(new SecureRandom(), 128));
048            return new SecretKeySpec(var0.generateKey(), "AES");
049        }
050    
051        public static KeyPair createNewKeyPair()
052        {
053            try
054            {
055                KeyPairGenerator var0 = KeyPairGenerator.getInstance("RSA");
056                var0.initialize(1024);
057                return var0.generateKeyPair();
058            }
059            catch (NoSuchAlgorithmException var1)
060            {
061                var1.printStackTrace();
062                System.err.println("Key pair generation failed!");
063                return null;
064            }
065        }
066    
067        public static byte[] func_75895_a(String par0Str, PublicKey par1PublicKey, SecretKey par2SecretKey)
068        {
069            try
070            {
071                return func_75893_a("SHA-1", new byte[][] {par0Str.getBytes("ISO_8859_1"), par2SecretKey.getEncoded(), par1PublicKey.getEncoded()});
072            }
073            catch (UnsupportedEncodingException var4)
074            {
075                var4.printStackTrace();
076                return null;
077            }
078        }
079    
080        private static byte[] func_75893_a(String par0Str, byte[] ... par1ArrayOfByte)
081        {
082            try
083            {
084                MessageDigest var2 = MessageDigest.getInstance(par0Str);
085                byte[][] var3 = par1ArrayOfByte;
086                int var4 = par1ArrayOfByte.length;
087    
088                for (int var5 = 0; var5 < var4; ++var5)
089                {
090                    byte[] var6 = var3[var5];
091                    var2.update(var6);
092                }
093    
094                return var2.digest();
095            }
096            catch (NoSuchAlgorithmException var7)
097            {
098                var7.printStackTrace();
099                return null;
100            }
101        }
102    
103        public static PublicKey func_75896_a(byte[] par0ArrayOfByte)
104        {
105            try
106            {
107                X509EncodedKeySpec var1 = new X509EncodedKeySpec(par0ArrayOfByte);
108                KeyFactory var2 = KeyFactory.getInstance("RSA");
109                return var2.generatePublic(var1);
110            }
111            catch (NoSuchAlgorithmException var3)
112            {
113                var3.printStackTrace();
114            }
115            catch (InvalidKeySpecException var4)
116            {
117                var4.printStackTrace();
118            }
119    
120            System.err.println("Public key reconstitute failed!");
121            return null;
122        }
123    
124        public static SecretKey func_75887_a(PrivateKey par0PrivateKey, byte[] par1ArrayOfByte)
125        {
126            return new SecretKeySpec(func_75889_b(par0PrivateKey, par1ArrayOfByte), "AES");
127        }
128    
129        @SideOnly(Side.CLIENT)
130        public static byte[] func_75894_a(Key par0Key, byte[] par1ArrayOfByte)
131        {
132            return func_75885_a(1, par0Key, par1ArrayOfByte);
133        }
134    
135        public static byte[] func_75889_b(Key par0Key, byte[] par1ArrayOfByte)
136        {
137            return func_75885_a(2, par0Key, par1ArrayOfByte);
138        }
139    
140        private static byte[] func_75885_a(int par0, Key par1Key, byte[] par2ArrayOfByte)
141        {
142            try
143            {
144                return func_75886_a(par0, par1Key.getAlgorithm(), par1Key).doFinal(par2ArrayOfByte);
145            }
146            catch (IllegalBlockSizeException var4)
147            {
148                var4.printStackTrace();
149            }
150            catch (BadPaddingException var5)
151            {
152                var5.printStackTrace();
153            }
154    
155            System.err.println("Cipher data failed!");
156            return null;
157        }
158    
159        private static Cipher func_75886_a(int par0, String par1Str, Key par2Key)
160        {
161            try
162            {
163                Cipher var3 = Cipher.getInstance(par1Str);
164                var3.init(par0, par2Key);
165                return var3;
166            }
167            catch (InvalidKeyException var4)
168            {
169                var4.printStackTrace();
170            }
171            catch (NoSuchAlgorithmException var5)
172            {
173                var5.printStackTrace();
174            }
175            catch (NoSuchPaddingException var6)
176            {
177                var6.printStackTrace();
178            }
179    
180            System.err.println("Cipher creation failed!");
181            return null;
182        }
183    
184        private static BufferedBlockCipher func_75892_a(boolean par0, Key par1Key)
185        {
186            BufferedBlockCipher var2 = new BufferedBlockCipher(new CFBBlockCipher(new AESFastEngine(), 8));
187            var2.init(par0, new ParametersWithIV(new KeyParameter(par1Key.getEncoded()), par1Key.getEncoded(), 0, 16));
188            return var2;
189        }
190    
191        public static OutputStream encryptOuputStream(SecretKey par0SecretKey, OutputStream par1OutputStream)
192        {
193            return new CipherOutputStream(par1OutputStream, func_75892_a(true, par0SecretKey));
194        }
195    
196        public static InputStream decryptInputStream(SecretKey par0SecretKey, InputStream par1InputStream)
197        {
198            return new CipherInputStream(par1InputStream, func_75892_a(false, par0SecretKey));
199        }
200    
201        static
202        {
203            Security.addProvider(new BouncyCastleProvider());
204        }
205    }