Fix issues with decoding and Java fallback native

native/src/main/java/com/velocitypowered/natives/encryption/JavaVelocityCipher.java

@@ -37,12 +37,13 @@ public class JavaVelocityCipher implements VelocityCipher {
   @Override
   public void process(ByteBuf source) {
     ensureNotDisposed();
+    Preconditions.checkArgument(source.hasArray(), "No source array");
 
     int inBytes = source.readableBytes();
-    byte[] asBytes = ByteBufUtil.getBytes(source);
 
     try {
-      cipher.update(asBytes, 0, inBytes, asBytes);
+      cipher.update(source.array(), source.arrayOffset(), inBytes, source.array(),
+          source.arrayOffset());
     } catch (ShortBufferException ex) {
       /* This _really_ shouldn't happen - AES CFB8 will work in place.
          If you run into this, that means that for whatever reason the Java Runtime has determined
@@ -64,6 +65,6 @@ public class JavaVelocityCipher implements VelocityCipher {
 
   @Override
   public BufferPreference preferredBufferType() {
-    return BufferPreference.HEAP_PREFERRED;
+    return BufferPreference.HEAP_REQUIRED;
   }
 }

native/src/main/java/com/velocitypowered/natives/util/BufferPreference.java

@@ -1,6 +1,10 @@
 package com.velocitypowered.natives.util;
 
 public enum BufferPreference {
+  /**
+   * A heap buffer is required.
+   */
+  HEAP_REQUIRED,
   /**
    * A heap buffer is preferred (but not required).
    */

native/src/main/java/com/velocitypowered/natives/util/MoreByteBufUtils.java

@@ -20,28 +20,30 @@ public class MoreByteBufUtils {
    * @return a buffer compatible with the native
    */
   public static ByteBuf ensureCompatible(ByteBufAllocator alloc, Native nativeStuff, ByteBuf buf) {
-    if (nativeStuff.preferredBufferType() != BufferPreference.DIRECT_REQUIRED
+    if (isCompatible(nativeStuff, buf)) {
-        || buf.hasMemoryAddress()) {
       return buf.retain();
     }
 
     // It's not, so we must make a direct copy.
-    ByteBuf newBuf = alloc.directBuffer(buf.readableBytes());
+    ByteBuf newBuf = preferredBuffer(alloc, nativeStuff, buf.readableBytes());
     newBuf.writeBytes(buf);
     return newBuf;
   }
 
-  /**
+  private static boolean isCompatible(Native nativeStuff, ByteBuf buf) {
-   * Creates a {@link ByteBuf} that will have the best performance with the specified
+    BufferPreference preferred = nativeStuff.preferredBufferType();
-   * {@code nativeStuff}.
+    switch (preferred) {
-   *
+      case DIRECT_PREFERRED:
-   * @param alloc the {@link ByteBufAllocator} to use
+      case HEAP_PREFERRED:
-   * @param nativeStuff the native we are working with
+        // The native prefers this type, but doesn't strictly require we provide it.
-   * @return a buffer compatible with the native
+        return true;
-   */
+      case DIRECT_REQUIRED:
-  public static ByteBuf preferredBuffer(ByteBufAllocator alloc, Native nativeStuff) {
+        return buf.hasMemoryAddress();
-    return nativeStuff.preferredBufferType() != BufferPreference.HEAP_PREFERRED
+      case HEAP_REQUIRED:
-        ? alloc.directBuffer() : alloc.heapBuffer();
+        return buf.hasArray();
+      default:
+        throw new AssertionError("Preferred buffer type unknown");
+    }
   }
 
   /**
@@ -55,7 +57,15 @@ public class MoreByteBufUtils {
    */
   public static ByteBuf preferredBuffer(ByteBufAllocator alloc, Native nativeStuff,
       int initialCapacity) {
-    return nativeStuff.preferredBufferType() != BufferPreference.HEAP_PREFERRED
+    switch (nativeStuff.preferredBufferType()) {
-        ? alloc.directBuffer(initialCapacity) : alloc.heapBuffer(initialCapacity);
+      case HEAP_REQUIRED:
+      case HEAP_PREFERRED:
+        return alloc.heapBuffer(initialCapacity);
+      case DIRECT_PREFERRED:
+      case DIRECT_REQUIRED:
+        return alloc.directBuffer(initialCapacity);
+      default:
+        throw new AssertionError("Preferred buffer type unknown");
+    }
   }
 }

proxy/src/main/java/com/velocitypowered/proxy/protocol/netty/MinecraftCipherDecoder.java

@@ -18,10 +18,11 @@ public class MinecraftCipherDecoder extends ByteToMessageDecoder {
 
   @Override
   protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
-    ByteBuf compatible = MoreByteBufUtils.ensureCompatible(ctx.alloc(), cipher, in);
+    ByteBuf compatible = MoreByteBufUtils.ensureCompatible(ctx.alloc(), cipher, in).slice();
     try {
       cipher.process(compatible);
       out.add(compatible);
+      in.skipBytes(in.readableBytes());
     } catch (Exception e) {
       compatible.release(); // compatible will never be used if we throw an exception
       throw e;