001 package net.minecraft.util; 002 003 import cpw.mods.fml.common.Side; 004 import cpw.mods.fml.common.asm.ReobfuscationMarker; 005 import cpw.mods.fml.common.asm.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 }