# Byte Array kommt nicht an



## MR_UNIX (28. Mrz 2014)

Moin,

ich versuche gerade einen RSA Public Key über das Netzwerk zu verschicken. Das Byte-Array was den Key enthält, kommt aber seltsamerweise nicht auf der Clientseite an, wird aber im Server losgeschickt und der Stream auch geflusht.
Habt ihr da zufällig eine Idee? Hier der Code:

Serverseitig:

```
if (reader.readLine().equalsIgnoreCase("FIRSTRUN"))
			{
				// Write server public key
				X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Storage.getKeyPair().getPublic().getEncoded());
				byte[] keyBuffer = x509EncodedKeySpec.getEncoded();
				writer.write(keyBuffer.length);
				writer.flush();
				this.targetUser.getOutputStream().write(keyBuffer);
				this.targetUser.getOutputStream().flush();
				System.out.println("hallo " + keyBuffer.length);
				
				// Try to receive client public key
				if (reader.readLine().equalsIgnoreCase("PUBKEY"))
				{
					int keylength = reader.read();
					byte[] clientPubkeyBuffer = new byte[keylength];
					this.targetUser.getInputStream().read(clientPubkeyBuffer);
					
					KeyFactory keyFactory = KeyFactory.getInstance("RSA");
					X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(clientPubkeyBuffer);
					PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
					
					IMServer.getServer().getCache().addKey(this.targetUser, publicKey);
				}
				else
				{
					writer.write("err_protocol_firstrun\n");
					writer.flush();
					
					writer.close();
					this.targetUser.logout();
					this.targetUser = null;
				}
			}
```

Clientseitig:

```
try
		{
			encryption = Cipher.getInstance("RSA");
			decryption = Cipher.getInstance("RSA");
			
			Socket socket = new Socket("localhost", 22558);
			BufferedInputStream binaryInput = new BufferedInputStream(socket.getInputStream());
			BufferedOutputStream binaryOutput = new BufferedOutputStream(socket.getOutputStream());
			
			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
			BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			
			KeyPair keypair = KeyPairGenerator.getInstance("RSA").generateKeyPair();
			
			X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keypair.getPublic().getEncoded());
			
			PublicKey serverPublic = null;
			
			System.out.println("writing first run command");
			
			writer.write("FIRSTRUN\n");
			writer.flush();
			
			System.out.println("reading key length");
			
			byte[] keyBuffer = new byte[reader.read()];
			System.out.println("reading key (length=" + keyBuffer.length + ")");
			binaryInput.read(keyBuffer);
			
			System.out.println("generating key from server");
			X509EncodedKeySpec serverKeySpec = new X509EncodedKeySpec(keyBuffer);
			serverPublic = KeyFactory.getInstance("RSA").generatePublic(serverKeySpec);
			
			System.out.println("init ciphers");
			encryption.init(Cipher.ENCRYPT_MODE, serverPublic);
			decryption.init(Cipher.DECRYPT_MODE, keypair.getPrivate());
			
			System.out.println("writing pubkey command");
			writer.write("PUBKEY\n");
			writer.flush();
			
			System.out.println("writing key length");
			writer.write(x509EncodedKeySpec.getEncoded().length);
			writer.flush();
			
			System.out.println("writing key");
			binaryOutput.write(x509EncodedKeySpec.getEncoded());
			binaryOutput.flush();
			
			System.out.println("waiting for answer");
			String encryptedKeycheck = reader.readLine();

			System.out.println("decoding answer");
			BASE64Decoder myDecoder = new BASE64Decoder();
			byte[] cryptedBuffer = myDecoder.decodeBuffer(encryptedKeycheck);
		    String decryptedKeycheck =  new String(decryption.doFinal(cryptedBuffer));
		    
		    System.out.println(decryptedKeycheck);
		}
		catch (Exception ex)
		{
			ex.printStackTrace();
		}
```

Die Konsolenausgabe im Client kommt bis "reading key (length=162)", sprich die Länge des Schlüssels wurde erfolgreich übertragen und sie stimmt auch mit der überein, die am Server ausgegeben wird. Der erste Punkt, der mich stutzig macht ist aber, dass die Länge eben nur 162 Byte beträgt, was irgendwie keine gewöhnliche Größe ist. Liegt das am Encoding?

Hoffentlich kann mir wer helfen.


----------

