provides full implementation of AuthMetadataFlyweight

Signed-off-by: Oleh Dokuka <[email protected]>

Author: OlegDokuka

rsocket-core/src/main/java/io/rsocket/buffer/AbstractTupleByteBuf.java

@@ -550,7 +550,7 @@ public int writeCharSequence(CharSequence sequence, Charset charset) {
 
   @Override
   public ByteBuffer internalNioBuffer(int index, int length) {
-    throw new UnsupportedOperationException();
+    return nioBuffer(index, length);
   }
 
   @Override

rsocket-core/src/main/java/io/rsocket/metadata/security/AuthMetadataFlyweight.java

@@ -3,6 +3,8 @@
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
 import io.netty.buffer.ByteBufUtil;
+import io.netty.buffer.Unpooled;
+import io.netty.util.CharsetUtil;
 import io.rsocket.buffer.TupleByteBuf;
 import io.rsocket.util.CharByteBufUtil;
 
@@ -14,6 +16,8 @@ public class AuthMetadataFlyweight {
   static final int USERNAME_BYTES_LENGTH = 1;
   static final int AUTH_TYPE_ID_LENGTH = 1;
 
+  static final char[] EMPTY_CHARS_ARRAY = new char[0];
+
   private AuthMetadataFlyweight() {}
 
   /**
@@ -80,7 +84,7 @@ public static ByteBuf encodeMetadata(
   /**
    * Encode a Authentication CompositeMetadata payload using Simple Authentication format
    *
-   * @throws IllegalArgumentException if username length is greater than 128
+   * @throws IllegalArgumentException if username length is greater than 256
    * @param allocator the {@link ByteBufAllocator} to use to create intermediate buffers as needed.
    * @param username the char sequence which represents user name.
    * @param password the char sequence which represents user password.
@@ -89,9 +93,9 @@ public static ByteBuf encodeSimpleMetadata(
       ByteBufAllocator allocator, char[] username, char[] password) {
 
     int usernameLength = CharByteBufUtil.utf8Bytes(username);
-    if (usernameLength > 128) {
+    if (usernameLength > 256) {
       throw new IllegalArgumentException(
-          "Username should be shorter than or equal to 128 bytes length in UTF-8 encoding");
+          "Username should be shorter than or equal to 256 bytes length in UTF-8 encoding");
     }
 
     int passwordLength = CharByteBufUtil.utf8Bytes(password);
@@ -152,4 +156,183 @@ public static ByteBuf encodeMetadataWithCompression(
       return AuthMetadataFlyweight.encodeMetadata(allocator, wkn, metadata);
     }
   }
+
+  /**
+   * Get the first {@code byte} from a {@link ByteBuf} and check whether it is length or {@link
+   * WellKnownAuthType}. Assuming said buffer properly contains such a {@code byte}
+   *
+   * @param metadata byteBuf used to get information from
+   */
+  public static boolean isWellKnownAuthType(ByteBuf metadata) {
+    byte lengthOrId = metadata.getByte(0);
+    return (lengthOrId & STREAM_METADATA_LENGTH_MASK) != lengthOrId;
+  }
+
+  /**
+   * Read first byte from the given {@code metadata} and tries to convert it's value to {@link
+   * WellKnownAuthType}.
+   *
+   * @param metadata given metadata buffer to read from
+   * @return Return on of the know Auth types or {@link WellKnownAuthType#UNPARSEABLE_AUTH_TYPE} if
+   *     field's value is length or unknown auth type
+   * @throws IllegalStateException if not enough readable bytes in the given ByteBuf
+   */
+  public static WellKnownAuthType decodeWellKnownAuthType(ByteBuf metadata) {
+    if (metadata.readableBytes() < 1) {
+      throw new IllegalStateException(
+          "Unable to decode Well Know Auth type. Not enough readable bytes");
+    }
+    byte lengthOrId = metadata.readByte();
+    int normalizedId = (byte) (lengthOrId & STREAM_METADATA_LENGTH_MASK);
+
+    if (normalizedId != lengthOrId) {
+      return WellKnownAuthType.fromIdentifier(normalizedId);
+    }
+
+    return WellKnownAuthType.UNPARSEABLE_AUTH_TYPE;
+  }
+
+  /**
+   * Read up to 129 bytes from the given metadata in order to get the custom Auth Type
+   *
+   * @param metadata
+   * @return
+   */
+  public static CharSequence decodeCustomAuthType(ByteBuf metadata) {
+    if (metadata.readableBytes() < 2) {
+      throw new IllegalStateException(
+          "Unable to decode custom Auth type. Not enough readable bytes");
+    }
+
+    byte encodedLength = metadata.readByte();
+    if (encodedLength < 0) {
+      throw new IllegalStateException(
+          "Unable to decode custom Auth type. Incorrect auth type length");
+    }
+
+    // encoded length is realLength - 1 in order to avoid intersection with 0x00 authtype
+    int realLength = encodedLength + 1;
+    if (metadata.readableBytes() < realLength) {
+      throw new IllegalArgumentException(
+          "Unable to decode custom Auth type. Malformed length or auth type string");
+    }
+
+    return metadata.readCharSequence(realLength, CharsetUtil.US_ASCII);
+  }
+
+  /**
+   * Read all remaining {@code bytes} from the given {@link ByteBuf} and return sliced
+   * representation of a payload
+   *
+   * @param metadata metadata to get payload from. Please note, the {@code metadata#readIndex}
+   *     should be set to the beginning of the payload bytes
+   * @return sliced {@link ByteBuf} or {@link Unpooled#EMPTY_BUFFER} if no bytes readable in the
+   *     given one
+   */
+  public static ByteBuf decodePayload(ByteBuf metadata) {
+    if (metadata.readableBytes() == 0) {
+      return Unpooled.EMPTY_BUFFER;
+    }
+
+    return metadata.readSlice(metadata.readableBytes());
+  }
+
+  /**
+   * Read up to 257 {@code bytes} from the given {@link ByteBuf} where the first byte is username
+   * length and the subsequent number of bytes equal to decoded length
+   *
+   * @param simpleAuthMetadata the given metadata to read username from. Please note, the {@code
+   *     simpleAuthMetadata#readIndex} should be set to the username length byte
+   * @return sliced {@link ByteBuf} or {@link Unpooled#EMPTY_BUFFER} if username length is zero
+   */
+  public static ByteBuf decodeUsername(ByteBuf simpleAuthMetadata) {
+    short usernameLength = decodeUsernameLength(simpleAuthMetadata);
+
+    if (usernameLength == 0) {
+      return Unpooled.EMPTY_BUFFER;
+    }
+
+    return simpleAuthMetadata.readSlice(usernameLength);
+  }
+
+  /**
+   * Read all the remaining {@code byte}s from the given {@link ByteBuf} which represents user's
+   * password
+   *
+   * @param simpleAuthMetadata the given metadata to read password from. Please note, the {@code
+   *     simpleAuthMetadata#readIndex} should be set to the beginning of the password bytes
+   * @return sliced {@link ByteBuf} or {@link Unpooled#EMPTY_BUFFER} if password length is zero
+   */
+  public static ByteBuf decodePassword(ByteBuf simpleAuthMetadata) {
+    if (simpleAuthMetadata.readableBytes() == 0) {
+      return Unpooled.EMPTY_BUFFER;
+    }
+
+    return simpleAuthMetadata.readSlice(simpleAuthMetadata.readableBytes());
+  }
+  /**
+   * Read up to 257 {@code bytes} from the given {@link ByteBuf} where the first byte is username
+   * length and the subsequent number of bytes equal to decoded length
+   *
+   * @param simpleAuthMetadata the given metadata to read username from. Please note, the {@code
+   *     simpleAuthMetadata#readIndex} should be set to the username length byte
+   * @return {@code char[]} which represents UTF-8 username
+   */
+  public static char[] decodeUsernameAsCharArray(ByteBuf simpleAuthMetadata) {
+    short usernameLength = decodeUsernameLength(simpleAuthMetadata);
+
+    if (usernameLength == 0) {
+      return EMPTY_CHARS_ARRAY;
+    }
+
+    return CharByteBufUtil.readUtf8(simpleAuthMetadata, usernameLength);
+  }
+
+  /**
+   * Read all the remaining {@code byte}s from the given {@link ByteBuf} which represents user's
+   * password
+   *
+   * @param simpleAuthMetadata the given metadata to read username from. Please note, the {@code
+   *     simpleAuthMetadata#readIndex} should be set to the beginning of the password bytes
+   * @return {@code char[]} which represents UTF-8 password
+   */
+  public static char[] decodePasswordAsCharArray(ByteBuf simpleAuthMetadata) {
+    if (simpleAuthMetadata.readableBytes() == 0) {
+      return EMPTY_CHARS_ARRAY;
+    }
+
+    return CharByteBufUtil.readUtf8(simpleAuthMetadata, simpleAuthMetadata.readableBytes());
+  }
+
+  /**
+   * Read all the remaining {@code bytes} from the given {@link ByteBuf} where the first byte is
+   * username length and the subsequent number of bytes equal to decoded length
+   *
+   * @param bearerAuthMetadata the given metadata to read username from. Please note, the {@code
+   *     simpleAuthMetadata#readIndex} should be set to the beginning of the password bytes
+   * @return {@code char[]} which represents UTF-8 password
+   */
+  public static char[] decodeBearerTokenAsCharArray(ByteBuf bearerAuthMetadata) {
+    if (bearerAuthMetadata.readableBytes() == 0) {
+      return EMPTY_CHARS_ARRAY;
+    }
+
+    return CharByteBufUtil.readUtf8(bearerAuthMetadata, bearerAuthMetadata.readableBytes());
+  }
+
+  private static short decodeUsernameLength(ByteBuf simpleAuthMetadata) {
+    if (simpleAuthMetadata.readableBytes() < 1) {
+      throw new IllegalStateException(
+          "Unable to decode custom username. Not enough readable bytes");
+    }
+
+    short usernameLength = simpleAuthMetadata.readUnsignedByte();
+
+    if (simpleAuthMetadata.readableBytes() < usernameLength) {
+      throw new IllegalArgumentException(
+          "Unable to decode username. Malformed username length or content");
+    }
+
+    return usernameLength;
+  }
 }

rsocket-core/src/main/java/io/rsocket/util/CharByteBufUtil.java

@@ -3,7 +3,14 @@
 import static io.netty.util.internal.StringUtil.isSurrogate;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.util.CharsetUtil;
 import io.netty.util.internal.MathUtil;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CoderResult;
+import java.util.Arrays;
 
 public class CharByteBufUtil {
 
@@ -168,4 +175,34 @@ private static int writeUtf8Surrogate(ByteBuf buffer, int writerIndex, char c, c
     buffer.setByte(writerIndex++, (byte) (0x80 | (codePoint & 0x3f)));
     return writerIndex;
   }
+
+  public static char[] readUtf8(ByteBuf byteBuf, int length) {
+    CharsetDecoder charsetDecoder = CharsetUtil.UTF_8.newDecoder();
+    int en = (int) (length * (double) charsetDecoder.maxCharsPerByte());
+    char[] ca = new char[en];
+
+    CharBuffer charBuffer = CharBuffer.wrap(ca);
+    ByteBuffer byteBuffer = byteBuf.internalNioBuffer(byteBuf.readerIndex(), length);
+    byteBuffer.mark();
+    try {
+      CoderResult cr = charsetDecoder.decode(byteBuffer, charBuffer, true);
+      if (!cr.isUnderflow()) cr.throwException();
+      cr = charsetDecoder.flush(charBuffer);
+      if (!cr.isUnderflow()) cr.throwException();
+
+      byteBuffer.reset();
+      byteBuf.skipBytes(length);
+
+      return safeTrim(charBuffer.array(), charBuffer.position());
+    } catch (CharacterCodingException x) {
+      // Substitution is always enabled,
+      // so this shouldn't happen
+      throw new IllegalStateException("unable to decode char array from the given buffer", x);
+    }
+  }
+
+  private static char[] safeTrim(char[] ca, int len) {
+    if (len == ca.length) return ca;
+    else return Arrays.copyOf(ca, len);
+  }
 }