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 }