Eclipse
/
jetty.project
mirror of https://github.com/jetty/jetty.project.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Issue #2909 - Remove B64Code 

Signed-off-by: Joakim Erdfelt <joakim.erdfelt@gmail.com>
This commit is contained in:
Joakim Erdfelt 2019-06-20 11:15:04 -05:00
parent 93b6619f8f
commit ef36cde4ed
6 changed files with 12 additions and 721 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

571
jetty-util/src/main/java/org/eclipse/jetty/util/B64Code.java
View File

@ -1,571 +0,0 @@
//
// ========================================================================
// Copyright (c) 1995-2019 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.util;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.charset.UnsupportedCharsetException;
import java.util.Base64;
/** Fast B64 Encoder/Decoder as described in RFC 1421.
* <p>Does not insert or interpret whitespace as described in RFC
* 1521. If you require this you must pre/post process your data.
* <p> Note that in a web context the usual case is to not want
* linebreaks or other white space in the encoded output.
* @deprecated use {@link java.util.Base64} instead
*/
@Deprecated
public class B64Code
{
private static final char __pad='=';
private static final char[] __rfc1421alphabet=
{
'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'
};
private static final byte[] __rfc1421nibbles;
static
{
__rfc1421nibbles=new byte[256];
for (int i=0;i<256;i++)
__rfc1421nibbles[i]=-1;
for (byte b=0;b<64;b++)
__rfc1421nibbles[(byte)__rfc1421alphabet[b]]=b;
__rfc1421nibbles[(byte)__pad]=0;
}
private static final char[] __rfc4648urlAlphabet=
{
'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
'w','x','y','z','0','1','2','3','4','5','6','7','8','9','-','_'
};
private static final byte[] __rfc4648urlNibbles;
static
{
__rfc4648urlNibbles=new byte[256];
for (int i=0;i<256;i++)
__rfc4648urlNibbles[i]=-1;
for (byte b=0;b<64;b++)
__rfc4648urlNibbles[(byte)__rfc4648urlAlphabet[b]]=b;
__rfc4648urlNibbles[(byte)__pad]=0;
}
private B64Code()
{
}
/**
* Base 64 encode as described in RFC 1421.
* <p>Does not insert whitespace as described in RFC 1521.
* @param s String to encode.
* @return String containing the encoded form of the input.
* @deprecated use {@link Base64.Encoder#encodeToString(byte[])}} instead.
*/
public static String encode(String s)
{
// FIXME: no Jetty mainline code uses this anymore
return encode(s, (Charset)null);
}
/**
* Base 64 encode as described in RFC 1421.
* <p>Does not insert whitespace as described in RFC 1521.
* @param s String to encode.
* @param charEncoding String representing the name of
* the character encoding of the provided input String.
* @return String containing the encoded form of the input.
*/
public static String encode(String s,String charEncoding)
{
// FIXME: no Jetty mainline code uses this anymore
byte[] bytes;
if (charEncoding==null)
bytes=s.getBytes(StandardCharsets.ISO_8859_1);
else
bytes=s.getBytes(Charset.forName(charEncoding));
return new String(encode(bytes));
}
/**
* Base 64 encode as described in RFC 1421.
* <p>Does not insert whitespace as described in RFC 1521.
* @param s String to encode.
* @param charEncoding The character encoding of the provided input String.
* @return String containing the encoded form of the input.
*/
public static String encode(String s, Charset charEncoding)
{
// FIXME: no Jetty mainline code uses this anymore
byte[] bytes=s.getBytes(charEncoding==null ? StandardCharsets.ISO_8859_1 : charEncoding);
return new String(encode(bytes));
}
/**
* Fast Base 64 encode as described in RFC 1421.
* <p>Does not insert whitespace as described in RFC 1521.
* <p> Avoids creating extra copies of the input/output.
* @param b byte array to encode.
* @return char array containing the encoded form of the input.
*/
public static char[] encode(byte[] b)
{
// FIXME: no Jetty mainline code uses this anymore
if (b==null)
return null;
int bLen=b.length;
int cLen=((bLen+2)/3)*4;
char c[]=new char[cLen];
int ci=0;
int bi=0;
byte b0, b1, b2;
int stop=(bLen/3)*3;
while (bi<stop)
{
b0=b[bi++];
b1=b[bi++];
b2=b[bi++];
c[ci++]=__rfc1421alphabet[(b0>>>2)&0x3f];
c[ci++]=__rfc1421alphabet[(b0<<4)&0x3f|(b1>>>4)&0x0f];
c[ci++]=__rfc1421alphabet[(b1<<2)&0x3f|(b2>>>6)&0x03];
c[ci++]=__rfc1421alphabet[b2&0x3f];
}
if (bLen!=bi)
{
switch (bLen%3)
{
case 2:
b0=b[bi++];
b1=b[bi++];
c[ci++]=__rfc1421alphabet[(b0>>>2)&0x3f];
c[ci++]=__rfc1421alphabet[(b0<<4)&0x3f|(b1>>>4)&0x0f];
c[ci++]=__rfc1421alphabet[(b1<<2)&0x3f];
c[ci++]=__pad;
break;
case 1:
b0=b[bi++];
c[ci++]=__rfc1421alphabet[(b0>>>2)&0x3f];
c[ci++]=__rfc1421alphabet[(b0<<4)&0x3f];
c[ci++]=__pad;
c[ci++]=__pad;
break;
default:
break;
}
}
return c;
}
/**
* Fast Base 64 encode as described in RFC 1421 and RFC2045
* <p>Does not insert whitespace as described in RFC 1521, unless rfc2045 is passed as true.
* <p> Avoids creating extra copies of the input/output.
* @param b byte array to encode.
* @param rfc2045 If true, break lines at 76 characters with CRLF
* @return char array containing the encoded form of the input.
*/
public static char[] encode(byte[] b, boolean rfc2045)
{
// FIXME: no Jetty mainline code uses this anymore
if (b==null)
return null;
if (!rfc2045)
return encode(b);
int bLen=b.length;
int cLen=((bLen+2)/3)*4;
cLen+=2+2*(cLen/76);
char c[]=new char[cLen];
int ci=0;
int bi=0;
byte b0, b1, b2;
int stop=(bLen/3)*3;
int l=0;
while (bi<stop)
{
b0=b[bi++];
b1=b[bi++];
b2=b[bi++];
c[ci++]=__rfc1421alphabet[(b0>>>2)&0x3f];
c[ci++]=__rfc1421alphabet[(b0<<4)&0x3f|(b1>>>4)&0x0f];
c[ci++]=__rfc1421alphabet[(b1<<2)&0x3f|(b2>>>6)&0x03];
c[ci++]=__rfc1421alphabet[b2&0x3f];
l+=4;
if (l%76==0)
{
c[ci++]=13;
c[ci++]=10;
}
}
if (bLen!=bi)
{
switch (bLen%3)
{
case 2:
b0=b[bi++];
b1=b[bi++];
c[ci++]=__rfc1421alphabet[(b0>>>2)&0x3f];
c[ci++]=__rfc1421alphabet[(b0<<4)&0x3f|(b1>>>4)&0x0f];
c[ci++]=__rfc1421alphabet[(b1<<2)&0x3f];
c[ci++]=__pad;
break;
case 1:
b0=b[bi++];
c[ci++]=__rfc1421alphabet[(b0>>>2)&0x3f];
c[ci++]=__rfc1421alphabet[(b0<<4)&0x3f];
c[ci++]=__pad;
c[ci++]=__pad;
break;
default:
break;
}
}
c[ci++]=13;
c[ci++]=10;
return c;
}
/**
* Base 64 decode as described in RFC 2045.
* <p>Unlike {@link #decode(char[])}, extra whitespace is ignored.
* @param encoded String to decode.
* @param charEncoding String representing the character encoding
* used to map the decoded bytes into a String. If null
* the platforms default charset is used.
* @return String decoded byte array.
* @throws UnsupportedCharsetException if the encoding is not supported
* @throws IllegalArgumentException if the input is not a valid
* B64 encoding.
*/
@SuppressWarnings("DefaultCharset")
public static String decode(String encoded,String charEncoding)
{
// FIXME: no Jetty mainline code uses this anymore
byte[] decoded=decode(encoded);
if (charEncoding==null)
return new String(decoded);
return new String(decoded,Charset.forName(charEncoding));
}
/**
* Base 64 decode as described in RFC 2045.
* <p>Unlike {@link #decode(char[])}, extra whitespace is ignored.
* @param encoded String to decode.
* @param charEncoding Character encoding
* used to map the decoded bytes into a String. If null
* the platforms default charset is used.
* @return String decoded byte array.
* @throws IllegalArgumentException if the input is not a valid
* B64 encoding.
*/
@SuppressWarnings("DefaultCharset")
public static String decode(String encoded, Charset charEncoding)
{
// FIXME: no Jetty mainline code uses this anymore
byte[] decoded=decode(encoded);
if (charEncoding==null)
return new String(decoded);
return new String(decoded, charEncoding);
}
/**
* Fast Base 64 decode as described in RFC 1421.
*
* <p>Unlike other decode methods, this does not attempt to
* cope with extra whitespace as described in RFC 1521/2045.
* <p> Avoids creating extra copies of the input/output.
* <p> Note this code has been flattened for performance.
* @param b char array to decode.
* @return byte array containing the decoded form of the input.
* @throws IllegalArgumentException if the input is not a valid
* B64 encoding.
*/
public static byte[] decode(char[] b)
{
// FIXME: no Jetty mainline code uses this anymore
if (b==null)
return null;
int bLen=b.length;
if (bLen%4!=0)
throw new IllegalArgumentException("Input block size is not 4");
int li=bLen-1;
while (li>=0 && b[li]==(byte)__pad)
li--;
if (li<0)
return new byte[0];
// Create result array of exact required size.
int rLen=((li+1)*3)/4;
byte r[]=new byte[rLen];
int ri=0;
int bi=0;
int stop=(rLen/3)*3;
byte b0,b1,b2,b3;
try
{
while (ri<stop)
{
b0=__rfc1421nibbles[b[bi++]];
b1=__rfc1421nibbles[b[bi++]];
b2=__rfc1421nibbles[b[bi++]];
b3=__rfc1421nibbles[b[bi++]];
if (b0<0 || b1<0 || b2<0 || b3<0)
throw new IllegalArgumentException("Not B64 encoded");
r[ri++]=(byte)(b0<<2|b1>>>4);
r[ri++]=(byte)(b1<<4|b2>>>2);
r[ri++]=(byte)(b2<<6|b3);
}
if (rLen!=ri)
{
switch (rLen%3)
{
case 2:
b0=__rfc1421nibbles[b[bi++]];
b1=__rfc1421nibbles[b[bi++]];
b2=__rfc1421nibbles[b[bi++]];
if (b0<0 || b1<0 || b2<0)
throw new IllegalArgumentException("Not B64 encoded");
r[ri++]=(byte)(b0<<2|b1>>>4);
r[ri++]=(byte)(b1<<4|b2>>>2);
break;
case 1:
b0=__rfc1421nibbles[b[bi++]];
b1=__rfc1421nibbles[b[bi++]];
if (b0<0 || b1<0)
throw new IllegalArgumentException("Not B64 encoded");
r[ri++]=(byte)(b0<<2|b1>>>4);
break;
default:
break;
}
}
}
catch (IndexOutOfBoundsException e)
{
throw new IllegalArgumentException("char "+bi
+" was not B64 encoded");
}
return r;
}
/**
* Base 64 decode as described in RFC 2045.
* <p>Unlike {@link #decode(char[])}, extra whitespace is ignored.
* @param encoded String to decode.
* @return byte array containing the decoded form of the input.
* @throws IllegalArgumentException if the input is not a valid
* B64 encoding.
*/
public static byte[] decode(String encoded)
{
// FIXME: no Jetty mainline code uses this anymore
if (encoded==null)
return null;
ByteArrayOutputStream bout = new ByteArrayOutputStream(4*encoded.length()/3);
decode(encoded, bout);
return bout.toByteArray();
}
/* ------------------------------------------------------------ */
/**
* Base 64 decode as described in RFC 2045.
* <p>Unlike {@link #decode(char[])}, extra whitespace is ignored.
* @param encoded String to decode.
* @param bout stream for decoded bytes
* @throws IllegalArgumentException if the input is not a valid
* B64 encoding.
*/
static public void decode(String encoded, ByteArrayOutputStream bout)
{
// FIXME: no Jetty mainline code uses this anymore
if (encoded==null)
return;
if (bout == null)
throw new IllegalArgumentException("No outputstream for decoded bytes");
int ci=0;
byte nibbles[] = new byte[4];
int s=0;
while (ci<encoded.length())
{
char c=encoded.charAt(ci++);
if (c==__pad)
break;
if (Character.isWhitespace(c))
continue;
byte nibble=__rfc1421nibbles[c];
if (nibble<0)
throw new IllegalArgumentException("Not B64 encoded");
nibbles[s++]=__rfc1421nibbles[c];
switch(s)
{
case 1:
break;
case 2:
bout.write(nibbles[0]<<2|nibbles[1]>>>4);
break;
case 3:
bout.write(nibbles[1]<<4|nibbles[2]>>>2);
break;
case 4:
bout.write(nibbles[2]<<6|nibbles[3]);
s=0;
break;
}
}
return;
}
/* ------------------------------------------------------------ */
public static byte[] decodeRFC4648URL(String encoded)
{
// FIXME: no Jetty mainline code uses this anymore
if (encoded==null)
return null;
ByteArrayOutputStream bout = new ByteArrayOutputStream(4*encoded.length()/3);
decodeRFC4648URL(encoded, bout);
return bout.toByteArray();
}
/* ------------------------------------------------------------ */
/**
* Base 64 decode as described in RFC 4648 URL.
* <p>Unlike {@link #decode(char[])}, extra whitespace is ignored.
* @param encoded String to decode.
* @param bout stream for decoded bytes
* @throws IllegalArgumentException if the input is not a valid
* B64 encoding.
*/
static public void decodeRFC4648URL (String encoded, ByteArrayOutputStream bout)
{
// FIXME: no Jetty mainline code uses this anymore
if (encoded==null)
return;
if (bout == null)
throw new IllegalArgumentException("No outputstream for decoded bytes");
int ci=0;
byte nibbles[] = new byte[4];
int s=0;
while (ci<encoded.length())
{
char c=encoded.charAt(ci++);
if (c==__pad)
break;
if (Character.isWhitespace(c))
continue;
byte nibble=__rfc4648urlNibbles[c];
if (nibble<0)
throw new IllegalArgumentException("Not B64 encoded");
nibbles[s++]=__rfc4648urlNibbles[c];
switch(s)
{
case 1:
break;
case 2:
bout.write(nibbles[0]<<2|nibbles[1]>>>4);
break;
case 3:
bout.write(nibbles[1]<<4|nibbles[2]>>>2);
break;
case 4:
bout.write(nibbles[2]<<6|nibbles[3]);
s=0;
break;
}
}
return;
}
public static void encode(int value,Appendable buf) throws IOException
{
// FIXME: no Jetty mainline code uses this anymore
buf.append(__rfc1421alphabet[0x3f&((0xFC000000&value)>>26)]);
buf.append(__rfc1421alphabet[0x3f&((0x03F00000&value)>>20)]);
buf.append(__rfc1421alphabet[0x3f&((0x000FC000&value)>>14)]);
buf.append(__rfc1421alphabet[0x3f&((0x00003F00&value)>>8)]);
buf.append(__rfc1421alphabet[0x3f&((0x000000FC&value)>>2)]);
buf.append(__rfc1421alphabet[0x3f&((0x00000003&value)<<4)]);
}
public static void encode(long lvalue,Appendable buf) throws IOException
{
// FIXME: no Jetty mainline code uses this anymore
int value=(int)(0xFFFFFFFC&(lvalue>>32));
buf.append(__rfc1421alphabet[0x3f&((0xFC000000&value)>>26)]);
buf.append(__rfc1421alphabet[0x3f&((0x03F00000&value)>>20)]);
buf.append(__rfc1421alphabet[0x3f&((0x000FC000&value)>>14)]);
buf.append(__rfc1421alphabet[0x3f&((0x00003F00&value)>>8)]);
buf.append(__rfc1421alphabet[0x3f&((0x000000FC&value)>>2)]);
buf.append(__rfc1421alphabet[0x3f&((0x00000003&value)<<4) + (0xf&(int)(lvalue>>28))]);
value=0x0FFFFFFF&(int)lvalue;
buf.append(__rfc1421alphabet[0x3f&((0x0FC00000&value)>>22)]);
buf.append(__rfc1421alphabet[0x3f&((0x003F0000&value)>>16)]);
buf.append(__rfc1421alphabet[0x3f&((0x0000FC00&value)>>10)]);
buf.append(__rfc1421alphabet[0x3f&((0x000003F0&value)>>4)]);
buf.append(__rfc1421alphabet[0x3f&((0x0000000F&value)<<2)]);
}
}

138
jetty-util/src/test/java/org/eclipse/jetty/util/B64CodeTest.java
View File

@ -1,138 +0,0 @@
//
// ========================================================================
// Copyright (c) 1995-2019 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.util;
import java.util.Base64;
import org.junit.jupiter.api.Test;
import static java.nio.charset.StandardCharsets.ISO_8859_1;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
public class B64CodeTest
{
String text = "Man is distinguished, not only by his reason, but by this singular passion " +
"from other animals, which is a lust of the mind, that by a perseverance of delight in " +
"the continued and indefatigable generation of knowledge, exceeds the short vehemence " +
"of any carnal pleasure.";
@Test
public void testEncode_RFC1421()
{
String expected = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz" +
"IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg" +
"dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu" +
"dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo" +
"ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=";
// Default Encode
String b64 = B64Code.encode(text, ISO_8859_1);
assertThat("B64Code.encode(String)", b64, is(expected));
// Specified RFC Encode
byte[] rawInputBytes = text.getBytes(ISO_8859_1);
char[] chars = B64Code.encode(rawInputBytes,false);
b64 = new String(chars,0,chars.length);
assertThat("B64Code.encode(byte[], false)", b64, is(expected));
// Standard Java Encode
String javaBase64 = Base64.getEncoder().encodeToString(rawInputBytes);
assertThat("Base64.getEncoder().encodeToString((byte[])", javaBase64, is(expected));
}
@Test
public void testEncode_RFC2045()
{
byte[] rawInputBytes = text.getBytes(ISO_8859_1);
// Old Jetty way
char[] chars = B64Code.encode(rawInputBytes,true);
String b64 = new String(chars,0,chars.length);
String expected = "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz\r\n"+
"IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg\r\n"+
"dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu\r\n"+
"dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo\r\n"+
"ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=\r\n";
assertThat(b64, is(expected));
// Standard Java way
String javaBase64 = Base64.getMimeEncoder().encodeToString(rawInputBytes);
// NOTE: MIME standard for encoding should not include final "\r\n"
assertThat(javaBase64 + "\r\n", is(expected));
}
@Test
public void testInteger() throws Exception
{
byte[] bytes = text.getBytes(ISO_8859_1);
int value = (bytes[0] << 24) +
(bytes[1] << 16) +
(bytes[2] << 8) +
(bytes[3]);
String expected = "TWFuIA";
// Old Jetty way
StringBuilder b = new StringBuilder();
B64Code.encode(value,b);
assertThat("Old Jetty B64Code", b.toString(), is(expected));
// Standard Java technique
byte[] intBytes = new byte[Integer.BYTES];
for (int i = Integer.BYTES - 1; i >= 0; i--)
{
intBytes[i] = (byte) (value & 0xFF);
value >>= 8;
}
assertThat("Standard Java Base64", Base64.getEncoder().withoutPadding().encodeToString(intBytes), is(expected));
}
@Test
public void testLong() throws Exception
{
byte[] bytes = text.getBytes(ISO_8859_1);
long value = ((0xffL & bytes[0]) << 56) +
((0xffL & bytes[1]) << 48) +
((0xffL & bytes[2]) << 40) +
((0xffL & bytes[3]) << 32) +
((0xffL & bytes[4]) << 24) +
((0xffL & bytes[5]) << 16) +
((0xffL & bytes[6]) << 8) +
(0xffL & bytes[7]);
String expected = "TWFuIGlzIGQ";
// Old Jetty way
StringBuilder b = new StringBuilder();
B64Code.encode(value,b);
assertThat("Old Jetty B64Code", b.toString(), is(expected));
// Standard Java technique
byte[] longBytes = new byte[Long.BYTES];
for (int i = Long.BYTES - 1; i >= 0; i--)
{
longBytes[i] = (byte) (value & 0xFF);
value >>= 8;
}
assertThat("Standard Java Base64", Base64.getEncoder().withoutPadding().encodeToString(longBytes), is(expected));
}
}

4
jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/client/ClientUpgradeRequest.java
View File

@ -20,6 +20,7 @@ package org.eclipse.jetty.websocket.core.client;
import java.net.URI; import java.net.URI;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Base64;
import java.util.List; import java.util.List;
import java.util.Locale; import java.util.Locale;
import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletableFuture;
@ -48,7 +49,6 @@ import org.eclipse.jetty.http.HttpVersion;
import org.eclipse.jetty.io.ByteBufferPool; import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.io.Connection; import org.eclipse.jetty.io.Connection;
import org.eclipse.jetty.io.EndPoint; import org.eclipse.jetty.io.EndPoint;
import org.eclipse.jetty.util.B64Code;
import org.eclipse.jetty.util.Callback; import org.eclipse.jetty.util.Callback;
import org.eclipse.jetty.util.QuotedStringTokenizer; import org.eclipse.jetty.util.QuotedStringTokenizer;
import org.eclipse.jetty.util.StringUtil; import org.eclipse.jetty.util.StringUtil;
@ -406,7 +406,7 @@ public abstract class ClientUpgradeRequest extends HttpRequest implements Respon
{ {
byte[] bytes = new byte[16]; byte[] bytes = new byte[16];
ThreadLocalRandom.current().nextBytes(bytes); ThreadLocalRandom.current().nextBytes(bytes);
return new String(B64Code.encode(bytes)); return Base64.getEncoder().encodeToString(bytes);
} }
private void initWebSocketHeaders() private void initWebSocketHeaders()

8
jetty-websocket/websocket-core/src/main/java/org/eclipse/jetty/websocket/core/internal/WebSocketCore.java
View File

@ -18,11 +18,11 @@
package org.eclipse.jetty.websocket.core.internal; package org.eclipse.jetty.websocket.core.internal;
import org.eclipse.jetty.util.B64Code;
import org.eclipse.jetty.websocket.core.WebSocketConstants;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.security.MessageDigest; import java.security.MessageDigest;
import java.util.Base64;
import org.eclipse.jetty.websocket.core.WebSocketConstants;
public final class WebSocketCore public final class WebSocketCore
{ {
@ -40,7 +40,7 @@ public final class WebSocketCore
MessageDigest md = MessageDigest.getInstance("SHA1"); MessageDigest md = MessageDigest.getInstance("SHA1");
md.update(key.getBytes(StandardCharsets.UTF_8)); md.update(key.getBytes(StandardCharsets.UTF_8));
md.update(WebSocketConstants.MAGIC); md.update(WebSocketConstants.MAGIC);
return new String(B64Code.encode(md.digest())); return Base64.getEncoder().encodeToString(md.digest());
} }
catch (Exception e) catch (Exception e)
{ {

8
jetty-websocket/websocket-core/src/test/java/org/eclipse/jetty/websocket/core/AcceptHashTest.java
View File

@ -18,15 +18,15 @@
package org.eclipse.jetty.websocket.core; package org.eclipse.jetty.websocket.core;
import org.eclipse.jetty.util.B64Code; import java.util.Base64;
import java.util.stream.Stream;
import org.eclipse.jetty.util.TypeUtil; import org.eclipse.jetty.util.TypeUtil;
import org.eclipse.jetty.websocket.core.internal.WebSocketCore; import org.eclipse.jetty.websocket.core.internal.WebSocketCore;
import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.MethodSource;
import java.util.stream.Stream;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is; import static org.hamcrest.Matchers.is;
@ -36,7 +36,7 @@ public class AcceptHashTest
{ {
byte key[] = TypeUtil.fromHexString(hex); byte key[] = TypeUtil.fromHexString(hex);
assertThat("Key size of hex:[" + hex + "]", key.length, is(16)); assertThat("Key size of hex:[" + hex + "]", key.length, is(16));
return String.valueOf(B64Code.encode(key)); return Base64.getEncoder().encodeToString(key);
} }
public static Stream<Arguments> data() public static Stream<Arguments> data()

4
jetty-websocket/websocket-core/src/test/java/org/eclipse/jetty/websocket/core/WebSocketTester.java
View File

@ -25,12 +25,12 @@ import java.net.InetSocketAddress;
import java.net.Socket; import java.net.Socket;
import java.nio.ByteBuffer; import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.Base64;
import org.eclipse.jetty.http.HttpFields; import org.eclipse.jetty.http.HttpFields;
import org.eclipse.jetty.http.HttpHeader; import org.eclipse.jetty.http.HttpHeader;
import org.eclipse.jetty.io.ArrayByteBufferPool; import org.eclipse.jetty.io.ArrayByteBufferPool;
import org.eclipse.jetty.io.ByteBufferPool; import org.eclipse.jetty.io.ByteBufferPool;
import org.eclipse.jetty.util.B64Code;
import org.eclipse.jetty.util.BufferUtil; import org.eclipse.jetty.util.BufferUtil;
import org.eclipse.jetty.util.ssl.SslContextFactory; import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.eclipse.jetty.websocket.core.internal.Parser; import org.eclipse.jetty.websocket.core.internal.Parser;
@ -44,7 +44,7 @@ import static org.hamcrest.Matchers.startsWith;
public class WebSocketTester public class WebSocketTester
{ {
private static String NON_RANDOM_KEY = new String(B64Code.encode("0123456701234567".getBytes())); private static String NON_RANDOM_KEY = Base64.getEncoder().encodeToString("0123456701234567".getBytes());
private static SslContextFactory.Client sslContextFactory; private static SslContextFactory.Client sslContextFactory;
protected ByteBufferPool bufferPool; protected ByteBufferPool bufferPool;
protected Parser parser; protected Parser parser;