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