archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-26 14:24:46 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8333364: Minor cleanup could be done in com.sun.crypto.provider

Browse source 
Reviewed-by: mullan, valeriep
This commit is contained in:
Mark Powers 2024-07-09 20:38:09 +00:00
parent 7e11fb7026
commit 1472124489
47 changed files with 313 additions and 367 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/java.base/share/classes/com/sun/crypto/provider/AESKeyGenerator.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,19 +25,19 @@
package com.sun.crypto.provider;
import java.security.SecureRandom;
import java.security.InvalidParameterException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.InvalidParameterException;
import java.security.SecureRandom;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Arrays;
import javax.crypto.KeyGeneratorSpi;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import sun.security.util.SecurityProviderConstants;
/**
* This class generates a AES key.
* This class generates an AES key.
*
* @author Valerie Peng
*
@ -105,7 +105,7 @@ public final class AESKeyGenerator extends KeyGeneratorSpi {
* @return the new AES key
*/
protected SecretKey engineGenerateKey() {
SecretKeySpec aesKey = null;
SecretKeySpec aesKey;
if (this.random == null) {
this.random = SunJCE.getRandom();

30
src/java.base/share/classes/com/sun/crypto/provider/AESKeyWrap.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,11 +25,11 @@
package com.sun.crypto.provider;
import java.util.Arrays;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import javax.crypto.IllegalBlockSizeException;
import static com.sun.crypto.provider.KWUtil.*;
/**
@ -66,7 +66,7 @@ class AESKeyWrap extends FeedbackCipher {
@Override
void save() {
throw new UnsupportedOperationException("save not supported");
};
}
/**
* Restores the content of this cipher to the previous saved one.
@ -74,7 +74,7 @@ class AESKeyWrap extends FeedbackCipher {
@Override
void restore() {
throw new UnsupportedOperationException("restore not supported");
};
}
/**
* Initializes the cipher in the specified mode with the given key
@ -112,20 +112,20 @@ class AESKeyWrap extends FeedbackCipher {
@Override
void reset() {
throw new UnsupportedOperationException("reset not supported");
};
}
// no support for multi-part encryption
// no support for multipart encryption
@Override
int encrypt(byte[] pt, int ptOfs, int ptLen, byte[] ct, int ctOfs) {
throw new UnsupportedOperationException("multi-part not supported");
};
throw new UnsupportedOperationException("multipart not supported");
}
// no support for multi-part decryption
// no support for multipart decryption
@Override
int decrypt(byte[] ct, int ctOfs, int ctLen, byte[] pt, int ptOfs) {
throw new UnsupportedOperationException("multi-part not supported");
};
throw new UnsupportedOperationException("multipart not supported");
}
/**
* Performs single-part encryption operation.

34
src/java.base/share/classes/com/sun/crypto/provider/AESKeyWrapPadded.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,12 +25,12 @@
package com.sun.crypto.provider;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.util.Arrays;
import java.util.HexFormat;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import javax.crypto.IllegalBlockSizeException;
import static com.sun.crypto.provider.KWUtil.*;
/**
@ -49,7 +49,7 @@ class AESKeyWrapPadded extends FeedbackCipher {
private static final byte[] PAD_BLK = new byte[SEMI_BLKSIZE - 1];
// set the first semiblock of dest with iv and inLen
// set the first semi-block of dest with iv and inLen
private static void setIvAndLen(byte[] dest, byte[] iv, int inLen) {
assert(dest.length >= SEMI_BLKSIZE) : "buffer needs at least 8 bytes";
@ -60,7 +60,7 @@ class AESKeyWrapPadded extends FeedbackCipher {
dest[7] = (byte) (inLen & 0xFF);
}
// validate the recovered internal ivAndLen semiblock against iv and
// validate the recovered internal ivAndLen semi-block against iv and
// return the recovered input length
private static int validateIV(byte[] ivAndLen, byte[] iv)
throws IllegalBlockSizeException {
@ -103,7 +103,7 @@ class AESKeyWrapPadded extends FeedbackCipher {
@Override
void save() {
throw new UnsupportedOperationException("save not supported");
};
}
/**
* Restores the content of this cipher to the previous saved one.
@ -111,7 +111,7 @@ class AESKeyWrapPadded extends FeedbackCipher {
@Override
void restore() {
throw new UnsupportedOperationException("restore not supported");
};
}
/**
* Initializes the cipher in the specified mode with the given key
@ -151,19 +151,19 @@ class AESKeyWrapPadded extends FeedbackCipher {
@Override
void reset() {
throw new UnsupportedOperationException("reset not supported");
};
}
// no support for multi-part encryption
// no support for multipart encryption
@Override
int encrypt(byte[] pt, int ptOfs, int ptLen, byte[] ct, int ctOfs) {
throw new UnsupportedOperationException("multi-part not supported");
};
throw new UnsupportedOperationException("multipart not supported");
}
// no support for multi-part decryption
// no support for multipart decryption
@Override
int decrypt(byte[] ct, int ctOfs, int ctLen, byte[] pt, int ptOfs) {
throw new UnsupportedOperationException("multi-part not supported");
};
throw new UnsupportedOperationException("multipart not supported");
}
/**
* Performs single-part encryption operation.
@ -199,7 +199,7 @@ class AESKeyWrapPadded extends FeedbackCipher {
}
if (ptLen <= BLKSIZE) {
// overwrite the first semiblock with iv and input length
// overwrite the first semi-block with iv and input length
setIvAndLen(pt, iv, actualLen);
embeddedCipher.encryptBlock(pt, 0, pt, 0);
} else {

8
src/java.base/share/classes/com/sun/crypto/provider/ARCFOURCipher.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -114,7 +114,7 @@ public sealed class ARCFOURCipher extends CipherSpi
// Modes do not make sense with stream ciphers, but allow ECB
// see JCE spec.
protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
if (mode.equalsIgnoreCase("ECB") == false) {
if (!mode.equalsIgnoreCase("ECB")) {
throw new NoSuchAlgorithmException("Unsupported mode " + mode);
}
}
@ -123,7 +123,7 @@ public sealed class ARCFOURCipher extends CipherSpi
// see JCE spec.
protected void engineSetPadding(String padding)
throws NoSuchPaddingException {
if (padding.equalsIgnoreCase("NoPadding") == false) {
if (!padding.equalsIgnoreCase("NoPadding")) {
throw new NoSuchPaddingException("Padding must be NoPadding");
}
}
@ -201,7 +201,7 @@ public sealed class ARCFOURCipher extends CipherSpi
if (!keyAlg.equals("RC4") && !keyAlg.equals("ARCFOUR")) {
throw new InvalidKeyException("Not an ARCFOUR key: " + keyAlg);
}
if ("RAW".equals(key.getFormat()) == false) {
if (!"RAW".equals(key.getFormat())) {
throw new InvalidKeyException("Key encoding format must be RAW");
}
byte[] encodedKey = key.getEncoded();

35
src/java.base/share/classes/com/sun/crypto/provider/ChaCha20Cipher.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -156,7 +156,7 @@ abstract class ChaCha20Cipher extends CipherSpi {
*/
@Override
protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
if (mode.equalsIgnoreCase("None") == false) {
if (!mode.equalsIgnoreCase("None")) {
throw new NoSuchAlgorithmException("Mode must be None");
}
}
@ -174,7 +174,7 @@ abstract class ChaCha20Cipher extends CipherSpi {
@Override
protected void engineSetPadding(String padding)
throws NoSuchPaddingException {
if (padding.equalsIgnoreCase("NoPadding") == false) {
if (!padding.equalsIgnoreCase("NoPadding")) {
throw new NoSuchPaddingException("Padding must be NoPadding");
}
}
@ -326,7 +326,7 @@ abstract class ChaCha20Cipher extends CipherSpi {
// We will ignore the secure random implementation and use the nonce
// from the AlgorithmParameterSpec instead.
byte[] newNonce = null;
byte[] newNonce;
switch (mode) {
case MODE_NONE:
if (!(params instanceof ChaCha20ParameterSpec)) {
@ -360,7 +360,7 @@ abstract class ChaCha20Cipher extends CipherSpi {
/**
* Initialize the engine using the {@code AlgorithmParameter} initialization
* format. This cipher does supports initialization with
* format. This cipher supports initialization with
* {@code AlgorithmParameter} objects for ChaCha20-Poly1305 but not for
* ChaCha20 as a simple stream cipher. In the latter case, it will throw
* an {@code InvalidAlgorithmParameterException} if the value is non-null.
@ -618,7 +618,7 @@ abstract class ChaCha20Cipher extends CipherSpi {
* or if the key encoding format is not {@code RAW}.
*/
private static byte[] getEncodedKey(Key key) throws InvalidKeyException {
if ("RAW".equals(key.getFormat()) == false) {
if (!"RAW".equals(key.getFormat())) {
throw new InvalidKeyException("Key encoding format must be RAW");
}
byte[] encodedKey = key.getEncoded();
@ -675,7 +675,7 @@ abstract class ChaCha20Cipher extends CipherSpi {
@Override
protected int engineUpdate(byte[] in, int inOfs, int inLen,
byte[] out, int outOfs) throws ShortBufferException {
int bytesUpdated = 0;
int bytesUpdated;
try {
bytesUpdated = engine.doUpdate(in, inOfs, inLen, out, outOfs);
} catch (KeyException ke) {
@ -691,10 +691,10 @@ abstract class ChaCha20Cipher extends CipherSpi {
* @param output ByteBuffer that will hold the resulting data. This
* must be large enough to hold the resulting data.
*
* @return the length in bytes of the data written into the {@code out}
* @return the length in bytes of the data written into the {@code output}
* buffer.
*
* @throws ShortBufferException if the buffer {@code out} does not have
* @throws ShortBufferException if the buffer {@code output} does not have
* enough space to hold the resulting data.
*/
@Override
@ -763,7 +763,7 @@ abstract class ChaCha20Cipher extends CipherSpi {
protected int engineDoFinal(byte[] in, int inOfs, int inLen, byte[] out,
int outOfs) throws ShortBufferException, AEADBadTagException {
int bytesUpdated = 0;
int bytesUpdated;
try {
bytesUpdated = engine.doFinal(in, inOfs, inLen, out, outOfs);
} catch (KeyException ke) {
@ -785,6 +785,9 @@ abstract class ChaCha20Cipher extends CipherSpi {
*
* @return the resulting plaintext or ciphertext bytes.
*
* @throws ShortBufferException if the buffer {@code output} does not have
* enough space to hold the resulting data.
*
* @throws AEADBadTagException if, during decryption, the provided tag
* does not match the calculated tag.
*/
@ -947,12 +950,8 @@ abstract class ChaCha20Cipher extends CipherSpi {
* key and nonce into their proper locations. The counter field is not
* set here.
*
* @throws IllegalArgumentException if the key or nonce are not in
* their proper lengths (32 bytes for the key, 12 bytes for the
* nonce).
* @throws InvalidKeyException if the key does not support an encoded form.
*/
private void setInitialState() throws InvalidKeyException {
private void setInitialState() {
// Apply constants to first 4 words
startState[0] = STATE_CONST_0;
startState[1] = STATE_CONST_1;
@ -1257,11 +1256,11 @@ abstract class ChaCha20Cipher extends CipherSpi {
* @param out the array to write the resulting tag into
* @param outOff the offset to begin writing the data.
*
* @throws ShortBufferException if there is insufficient room to
* @throws ProviderException if there is insufficient room to
* write the tag.
*/
private void authFinalizeData(byte[] data, int dataOff, int length,
byte[] out, int outOff) throws ShortBufferException {
byte[] out, int outOff) {
// Update with the final chunk of ciphertext, then pad to a
// multiple of 16.
if (data != null) {
@ -1300,7 +1299,7 @@ abstract class ChaCha20Cipher extends CipherSpi {
* @param dLen the length of the application data.
* @param buf the buffer to write the two lengths into.
*
* @note it is the caller's responsibility to provide an array large
* @implNote it is the caller's responsibility to provide an array large
* enough to hold the two longs.
*/
private void authWriteLengths(long aLen, long dLen, byte[] buf) {

7
src/java.base/share/classes/com/sun/crypto/provider/ChaCha20Poly1305Parameters.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -206,8 +206,7 @@ public final class ChaCha20Poly1305Parameters extends AlgorithmParametersSpi {
protected String engineToString() {
String LINE_SEP = System.lineSeparator();
HexDumpEncoder encoder = new HexDumpEncoder();
StringBuilder sb = new StringBuilder(LINE_SEP + "nonce:" +
LINE_SEP + "[" + encoder.encodeBuffer(nonce) + "]");
return sb.toString();
return LINE_SEP + "nonce:" +
LINE_SEP + "[" + encoder.encodeBuffer(nonce) + "]";
}
}

4
src/java.base/share/classes/com/sun/crypto/provider/CipherBlockChaining.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -180,7 +180,7 @@ class CipherBlockChaining extends FeedbackCipher {
*
* <p>It is also the application's responsibility to make sure that
* <code>init</code> has been called before this method is called.
* (This check is omitted here, to avoid double checking.)
* (This check is omitted here, to avoid double-checking.)
*
* @param cipher the buffer with the input data to be decrypted
* @param cipherOffset the offset in <code>cipherOffset</code>

21
src/java.base/share/classes/com/sun/crypto/provider/CipherCore.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -67,7 +67,7 @@ final class CipherCore {
/*
* unit size (number of input bytes that can be processed at a time)
*/
private int unitBytes = 0;
private int unitBytes;
/*
* index of the content size left in the buffer
@ -91,17 +91,17 @@ final class CipherCore {
* input bytes that are processed at a time is different from the block
* size)
*/
private int diffBlocksize = 0;
private int diffBlocksize;
/*
* padding class
*/
private Padding padding = null;
private Padding padding;
/*
* internal cipher engine
*/
private FeedbackCipher cipher = null;
private FeedbackCipher cipher;
/*
* the cipher mode
@ -136,7 +136,7 @@ final class CipherCore {
/*
* The buffer should be usable for all cipher mode and padding
* schemes. Thus, it has to be at least (blockSize+1) for CTS.
* In decryption mode, it also hold the possible padding block.
* In decryption mode, it also holds the possible padding block.
*/
buffer = new byte[blockSize*2];
@ -334,7 +334,7 @@ final class CipherCore {
if (cipherMode == ECB_MODE) {
return null;
}
AlgorithmParameters params = null;
AlgorithmParameters params;
AlgorithmParameterSpec spec;
byte[] iv = getIV();
if (iv == null) {
@ -545,7 +545,7 @@ final class CipherCore {
*/
byte[] update(byte[] input, int inputOffset, int inputLen) {
byte[] output = null;
byte[] output;
try {
output = new byte[getOutputSizeByOperation(inputLen, false)];
int len = update(input, inputOffset, inputLen, output,
@ -930,8 +930,7 @@ final class CipherCore {
private int fillOutputBuffer(byte[] finalBuf, int finalOffset,
byte[] output, int outOfs, int finalBufLen, byte[] input)
throws ShortBufferException, BadPaddingException,
IllegalBlockSizeException {
throws BadPaddingException, IllegalBlockSizeException {
int len;
try {
@ -967,7 +966,7 @@ final class CipherCore {
private int finalNoPadding(byte[] in, int inOfs, byte[] out, int outOfs,
int len)
throws IllegalBlockSizeException, ShortBufferException {
throws IllegalBlockSizeException {
if (in == null || len == 0) {
return 0;

5
src/java.base/share/classes/com/sun/crypto/provider/CipherTextStealing.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2004, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -26,7 +26,6 @@
package com.sun.crypto.provider;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.ShortBufferException;
/**
* This class represents ciphers in cipher text stealing (CTS) mode.
@ -153,7 +152,7 @@ final class CipherTextStealing extends CipherBlockChaining {
*
* <p>It is also the application's responsibility to make sure that
* <code>init</code> has been called before this method is called.
* (This check is omitted here, to avoid double checking.)
* (This check is omitted here, to avoid double-checking.)
*
* @param cipher the buffer with the input data to be decrypted
* @param cipherOffset the offset in <code>cipherOffset</code>

6
src/java.base/share/classes/com/sun/crypto/provider/ConstructKeys.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -54,7 +54,7 @@ final class ConstructKeys {
private static final PublicKey constructPublicKey(byte[] encodedKey,
int ofs, int len, String encodedKeyAlgorithm)
throws InvalidKeyException, NoSuchAlgorithmException {
PublicKey key = null;
PublicKey key;
byte[] keyBytes = (ofs == 0 && encodedKey.length == len)
? encodedKey : Arrays.copyOfRange(encodedKey, ofs, ofs + len);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
@ -88,7 +88,7 @@ final class ConstructKeys {
private static final PrivateKey constructPrivateKey(byte[] encodedKey,
int ofs, int len, String encodedKeyAlgorithm)
throws InvalidKeyException, NoSuchAlgorithmException {
PrivateKey key = null;
PrivateKey key;
byte[] keyBytes = (ofs == 0 && encodedKey.length == len)
? encodedKey : Arrays.copyOfRange(encodedKey, ofs, ofs + len);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

126
src/java.base/share/classes/com/sun/crypto/provider/DESCrypt.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -40,7 +40,7 @@ import java.security.InvalidKeyException;
*/
class DESCrypt extends SymmetricCipher implements DESConstants {
private static final int s0p[] = {
private static final int[] s0p = {
0x00410100, 0x00010000, 0x40400000, 0x40410100, 0x00400000,
0x40010100, 0x40010000, 0x40400000, 0x40010100, 0x00410100,
0x00410000, 0x40000100, 0x40400100, 0x00400000, 0x00000000,
@ -56,7 +56,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
0x40000000, 0x40410000, 0x00000100, 0x40010100,
};
private static final int s1p[] = {
private static final int[] s1p = {
0x08021002, 0x00000000, 0x00021000, 0x08020000, 0x08000002,
0x00001002, 0x08001000, 0x00021000, 0x00001000, 0x08020002,
0x00000002, 0x08001000, 0x00020002, 0x08021000, 0x08020000,
@ -72,7 +72,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
0x08001002, 0x00000002, 0x08020000, 0x00021000,
};
private static final int s2p[] = {
private static final int[] s2p = {
0x20800000, 0x00808020, 0x00000020, 0x20800020, 0x20008000,
0x00800000, 0x20800020, 0x00008020, 0x00800020, 0x00008000,
0x00808000, 0x20000000, 0x20808020, 0x20000020, 0x20000000,
@ -88,7 +88,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
0x20800000, 0x20008020, 0x00000020, 0x00808000,
};
private static final int s3p[] = {
private static final int[] s3p = {
0x00080201, 0x02000200, 0x00000001, 0x02080201, 0x00000000,
0x02080000, 0x02000201, 0x00080001, 0x02080200, 0x02000001,
0x02000000, 0x00000201, 0x02000001, 0x00080201, 0x00080000,
@ -104,7 +104,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
0x00000201, 0x02000000, 0x02000001, 0x02080200,
};
private static final int s4p[] = {
private static final int[] s4p = {
0x01000000, 0x00002000, 0x00000080, 0x01002084, 0x01002004,
0x01000080, 0x00002084, 0x01002000, 0x00002000, 0x00000004,
0x01000004, 0x00002080, 0x01000084, 0x01002004, 0x01002080,
@ -120,7 +120,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
0x00000004, 0x00002084, 0x01002000, 0x01000004,
};
private static final int s5p[] = {
private static final int[] s5p = {
0x10000008, 0x00040008, 0x00000000, 0x10040400, 0x00040008,
0x00000400, 0x10000408, 0x00040000, 0x00000408, 0x10040408,
0x00040400, 0x10000000, 0x10000400, 0x10000008, 0x10040000,
@ -136,7 +136,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
0x10040000, 0x00000408, 0x00000008, 0x10040008,
};
private static final int s6p[] = {
private static final int[] s6p = {
0x00000800, 0x00000040, 0x00200040, 0x80200000, 0x80200840,
0x80000800, 0x00000840, 0x00000000, 0x00200000, 0x80200040,
0x80000040, 0x00200800, 0x80000000, 0x00200840, 0x00200800,
@ -152,7 +152,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
0x80200000, 0x00200840, 0x00200800, 0x80000800,
};
private static final int s7p[] = {
private static final int[] s7p = {
0x04100010, 0x04104000, 0x00004010, 0x00000000, 0x04004000,
0x00100010, 0x04100000, 0x04104010, 0x00000010, 0x04000000,
0x00104000, 0x00004010, 0x00104010, 0x04004010, 0x04000010,
@ -168,112 +168,112 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
0x04000000, 0x04100010, 0x00004000, 0x00104010,
};
private static final int permRight0[] = {
private static final int[] permRight0 = {
0x00000000, 0x40000000, 0x00400000, 0x40400000, 0x00004000,
0x40004000, 0x00404000, 0x40404000, 0x00000040, 0x40000040,
0x00400040, 0x40400040, 0x00004040, 0x40004040, 0x00404040,
0x40404040,
};
private static final int permLeft1[] = {
private static final int[] permLeft1 = {
0x00000000, 0x40000000, 0x00400000, 0x40400000, 0x00004000,
0x40004000, 0x00404000, 0x40404000, 0x00000040, 0x40000040,
0x00400040, 0x40400040, 0x00004040, 0x40004040, 0x00404040,
0x40404040,
};
private static final int permRight2[] = {
private static final int[] permRight2 = {
0x00000000, 0x10000000, 0x00100000, 0x10100000, 0x00001000,
0x10001000, 0x00101000, 0x10101000, 0x00000010, 0x10000010,
0x00100010, 0x10100010, 0x00001010, 0x10001010, 0x00101010,
0x10101010,
};
private static final int permLeft3[] = {
private static final int[] permLeft3 = {
0x00000000, 0x10000000, 0x00100000, 0x10100000, 0x00001000,
0x10001000, 0x00101000, 0x10101000, 0x00000010, 0x10000010,
0x00100010, 0x10100010, 0x00001010, 0x10001010, 0x00101010,
0x10101010,
};
private static final int permRight4[] = {
private static final int[] permRight4 = {
0x00000000, 0x04000000, 0x00040000, 0x04040000, 0x00000400,
0x04000400, 0x00040400, 0x04040400, 0x00000004, 0x04000004,
0x00040004, 0x04040004, 0x00000404, 0x04000404, 0x00040404,
0x04040404,
};
private static final int permLeft5[] = {
private static final int[] permLeft5 = {
0x00000000, 0x04000000, 0x00040000, 0x04040000, 0x00000400,
0x04000400, 0x00040400, 0x04040400, 0x00000004, 0x04000004,
0x00040004, 0x04040004, 0x00000404, 0x04000404, 0x00040404,
0x04040404,
};
private static final int permRight6[] = {
private static final int[] permRight6 = {
0x00000000, 0x01000000, 0x00010000, 0x01010000, 0x00000100,
0x01000100, 0x00010100, 0x01010100, 0x00000001, 0x01000001,
0x00010001, 0x01010001, 0x00000101, 0x01000101, 0x00010101,
0x01010101,
};
private static final int permLeft7[] = {
private static final int[] permLeft7 = {
0x00000000, 0x01000000, 0x00010000, 0x01010000, 0x00000100,
0x01000100, 0x00010100, 0x01010100, 0x00000001, 0x01000001,
0x00010001, 0x01010001, 0x00000101, 0x01000101, 0x00010101,
0x01010101,
};
private static final int permRight8[] = {
private static final int[] permRight8 = {
0x00000000, 0x80000000, 0x00800000, 0x80800000, 0x00008000,
0x80008000, 0x00808000, 0x80808000, 0x00000080, 0x80000080,
0x00800080, 0x80800080, 0x00008080, 0x80008080, 0x00808080,
0x80808080,
};
private static final int permLeft9[] = {
private static final int[] permLeft9 = {
0x00000000, 0x80000000, 0x00800000, 0x80800000, 0x00008000,
0x80008000, 0x00808000, 0x80808000, 0x00000080, 0x80000080,
0x00800080, 0x80800080, 0x00008080, 0x80008080, 0x00808080,
0x80808080,
};
private static final int permRightA[] = {
private static final int[] permRightA = {
0x00000000, 0x20000000, 0x00200000, 0x20200000, 0x00002000,
0x20002000, 0x00202000, 0x20202000, 0x00000020, 0x20000020,
0x00200020, 0x20200020, 0x00002020, 0x20002020, 0x00202020,
0x20202020,
};
private static final int permLeftB[] = {
private static final int[] permLeftB = {
0x00000000, 0x20000000, 0x00200000, 0x20200000, 0x00002000,
0x20002000, 0x00202000, 0x20202000, 0x00000020, 0x20000020,
0x00200020, 0x20200020, 0x00002020, 0x20002020, 0x00202020,
0x20202020,
};
private static final int permRightC[] = {
private static final int[] permRightC = {
0x00000000, 0x08000000, 0x00080000, 0x08080000, 0x00000800,
0x08000800, 0x00080800, 0x08080800, 0x00000008, 0x08000008,
0x00080008, 0x08080008, 0x00000808, 0x08000808, 0x00080808,
0x08080808,
};
private static final int permLeftD[] = {
private static final int[] permLeftD = {
0x00000000, 0x08000000, 0x00080000, 0x08080000, 0x00000800,
0x08000800, 0x00080800, 0x08080800, 0x00000008, 0x08000008,
0x00080008, 0x08080008, 0x00000808, 0x08000808, 0x00080808,
0x08080808,
};
private static final int permRightE[] = {
private static final int[] permRightE = {
0x00000000, 0x02000000, 0x00020000, 0x02020000, 0x00000200,
0x02000200, 0x00020200, 0x02020200, 0x00000002, 0x02000002,
0x00020002, 0x02020002, 0x00000202, 0x02000202, 0x00020202,
0x02020202,
};
private static final int permLeftF[] = {
private static final int[] permLeftF = {
0x00000000, 0x02000000, 0x00020000, 0x02020000, 0x00000200,
0x02000200, 0x00020200, 0x02020200, 0x00000002, 0x02000002,
0x00020002, 0x02020002, 0x00000202, 0x02000202, 0x00020202,
@ -283,224 +283,224 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
/*
* Initial Permutation
*/
private static final int initPermLeft0[] = {
private static final int[] initPermLeft0 = {
0x00000000, 0x00008000, 0x00000000, 0x00008000, 0x00000080,
0x00008080, 0x00000080, 0x00008080, 0x00000000, 0x00008000,
0x00000000, 0x00008000, 0x00000080, 0x00008080, 0x00000080,
0x00008080,
};
private static final int initPermRight0[] = {
private static final int[] initPermRight0 = {
0x00000000, 0x00000000, 0x00008000, 0x00008000, 0x00000000,
0x00000000, 0x00008000, 0x00008000, 0x00000080, 0x00000080,
0x00008080, 0x00008080, 0x00000080, 0x00000080, 0x00008080,
0x00008080,
};
private static final int initPermLeft1[] = {
private static final int[] initPermLeft1 = {
0x00000000, 0x80000000, 0x00000000, 0x80000000, 0x00800000,
0x80800000, 0x00800000, 0x80800000, 0x00000000, 0x80000000,
0x00000000, 0x80000000, 0x00800000, 0x80800000, 0x00800000,
0x80800000,
};
private static final int initPermRight1[] = {
private static final int[] initPermRight1 = {
0x00000000, 0x00000000, 0x80000000, 0x80000000, 0x00000000,
0x00000000, 0x80000000, 0x80000000, 0x00800000, 0x00800000,
0x80800000, 0x80800000, 0x00800000, 0x00800000, 0x80800000,
0x80800000,
};
private static final int initPermLeft2[] = {
private static final int[] initPermLeft2 = {
0x00000000, 0x00004000, 0x00000000, 0x00004000, 0x00000040,
0x00004040, 0x00000040, 0x00004040, 0x00000000, 0x00004000,
0x00000000, 0x00004000, 0x00000040, 0x00004040, 0x00000040,
0x00004040,
};
private static final int initPermRight2[] = {
private static final int[] initPermRight2 = {
0x00000000, 0x00000000, 0x00004000, 0x00004000, 0x00000000,
0x00000000, 0x00004000, 0x00004000, 0x00000040, 0x00000040,
0x00004040, 0x00004040, 0x00000040, 0x00000040, 0x00004040,
0x00004040,
};
private static final int initPermLeft3[] = {
private static final int[] initPermLeft3 = {
0x00000000, 0x40000000, 0x00000000, 0x40000000, 0x00400000,
0x40400000, 0x00400000, 0x40400000, 0x00000000, 0x40000000,
0x00000000, 0x40000000, 0x00400000, 0x40400000, 0x00400000,
0x40400000,
};
private static final int initPermRight3[] = {
private static final int[] initPermRight3 = {
0x00000000, 0x00000000, 0x40000000, 0x40000000, 0x00000000,
0x00000000, 0x40000000, 0x40000000, 0x00400000, 0x00400000,
0x40400000, 0x40400000, 0x00400000, 0x00400000, 0x40400000,
0x40400000,
};
private static final int initPermLeft4[] = {
private static final int[] initPermLeft4 = {
0x00000000, 0x00002000, 0x00000000, 0x00002000, 0x00000020,
0x00002020, 0x00000020, 0x00002020, 0x00000000, 0x00002000,
0x00000000, 0x00002000, 0x00000020, 0x00002020, 0x00000020,
0x00002020,
};
private static final int initPermRight4[] = {
private static final int[] initPermRight4 = {
0x00000000, 0x00000000, 0x00002000, 0x00002000, 0x00000000,
0x00000000, 0x00002000, 0x00002000, 0x00000020, 0x00000020,
0x00002020, 0x00002020, 0x00000020, 0x00000020, 0x00002020,
0x00002020,
};
private static final int initPermLeft5[] = {
private static final int[] initPermLeft5 = {
0x00000000, 0x20000000, 0x00000000, 0x20000000, 0x00200000,
0x20200000, 0x00200000, 0x20200000, 0x00000000, 0x20000000,
0x00000000, 0x20000000, 0x00200000, 0x20200000, 0x00200000,
0x20200000,
};
private static final int initPermRight5[] = {
private static final int[] initPermRight5 = {
0x00000000, 0x00000000, 0x20000000, 0x20000000, 0x00000000,
0x00000000, 0x20000000, 0x20000000, 0x00200000, 0x00200000,
0x20200000, 0x20200000, 0x00200000, 0x00200000, 0x20200000,
0x20200000,
};
private static final int initPermLeft6[] = {
private static final int[] initPermLeft6 = {
0x00000000, 0x00001000, 0x00000000, 0x00001000, 0x00000010,
0x00001010, 0x00000010, 0x00001010, 0x00000000, 0x00001000,
0x00000000, 0x00001000, 0x00000010, 0x00001010, 0x00000010,
0x00001010,
};
private static final int initPermRight6[] = {
private static final int[] initPermRight6 = {
0x00000000, 0x00000000, 0x00001000, 0x00001000, 0x00000000,
0x00000000, 0x00001000, 0x00001000, 0x00000010, 0x00000010,
0x00001010, 0x00001010, 0x00000010, 0x00000010, 0x00001010,
0x00001010,
};
private static final int initPermLeft7[] = {
private static final int[] initPermLeft7 = {
0x00000000, 0x10000000, 0x00000000, 0x10000000, 0x00100000,
0x10100000, 0x00100000, 0x10100000, 0x00000000, 0x10000000,
0x00000000, 0x10000000, 0x00100000, 0x10100000, 0x00100000,
0x10100000,
};
private static final int initPermRight7[] = {
private static final int[] initPermRight7 = {
0x00000000, 0x00000000, 0x10000000, 0x10000000, 0x00000000,
0x00000000, 0x10000000, 0x10000000, 0x00100000, 0x00100000,
0x10100000, 0x10100000, 0x00100000, 0x00100000, 0x10100000,
0x10100000,
};
private static final int initPermLeft8[] = {
private static final int[] initPermLeft8 = {
0x00000000, 0x00000800, 0x00000000, 0x00000800, 0x00000008,
0x00000808, 0x00000008, 0x00000808, 0x00000000, 0x00000800,
0x00000000, 0x00000800, 0x00000008, 0x00000808, 0x00000008,
0x00000808,
};
private static final int initPermRight8[] = {
private static final int[] initPermRight8 = {
0x00000000, 0x00000000, 0x00000800, 0x00000800, 0x00000000,
0x00000000, 0x00000800, 0x00000800, 0x00000008, 0x00000008,
0x00000808, 0x00000808, 0x00000008, 0x00000008, 0x00000808,
0x00000808,
};
private static final int initPermLeft9[] = {
private static final int[] initPermLeft9 = {
0x00000000, 0x08000000, 0x00000000, 0x08000000, 0x00080000,
0x08080000, 0x00080000, 0x08080000, 0x00000000, 0x08000000,
0x00000000, 0x08000000, 0x00080000, 0x08080000, 0x00080000,
0x08080000,
};
private static final int initPermRight9[] = {
private static final int[] initPermRight9 = {
0x00000000, 0x00000000, 0x08000000, 0x08000000, 0x00000000,
0x00000000, 0x08000000, 0x08000000, 0x00080000, 0x00080000,
0x08080000, 0x08080000, 0x00080000, 0x00080000, 0x08080000,
0x08080000,
};
private static final int initPermLeftA[] = {
private static final int[] initPermLeftA = {
0x00000000, 0x00000400, 0x00000000, 0x00000400, 0x00000004,
0x00000404, 0x00000004, 0x00000404, 0x00000000, 0x00000400,
0x00000000, 0x00000400, 0x00000004, 0x00000404, 0x00000004,
0x00000404,
};
private static final int initPermRightA[] = {
private static final int[] initPermRightA = {
0x00000000, 0x00000000, 0x00000400, 0x00000400, 0x00000000,
0x00000000, 0x00000400, 0x00000400, 0x00000004, 0x00000004,
0x00000404, 0x00000404, 0x00000004, 0x00000004, 0x00000404,
0x00000404,
};
private static final int initPermLeftB[] = {
private static final int[] initPermLeftB = {
0x00000000, 0x04000000, 0x00000000, 0x04000000, 0x00040000,
0x04040000, 0x00040000, 0x04040000, 0x00000000, 0x04000000,
0x00000000, 0x04000000, 0x00040000, 0x04040000, 0x00040000,
0x04040000,
};
private static final int initPermRightB[] = {
private static final int[] initPermRightB = {
0x00000000, 0x00000000, 0x04000000, 0x04000000, 0x00000000,
0x00000000, 0x04000000, 0x04000000, 0x00040000, 0x00040000,
0x04040000, 0x04040000, 0x00040000, 0x00040000, 0x04040000,
0x04040000,
};
private static final int initPermLeftC[] = {
private static final int[] initPermLeftC = {
0x00000000, 0x00000200, 0x00000000, 0x00000200, 0x00000002,
0x00000202, 0x00000002, 0x00000202, 0x00000000, 0x00000200,
0x00000000, 0x00000200, 0x00000002, 0x00000202, 0x00000002,
0x00000202,
};
private static final int initPermRightC[] = {
private static final int[] initPermRightC = {
0x00000000, 0x00000000, 0x00000200, 0x00000200, 0x00000000,
0x00000000, 0x00000200, 0x00000200, 0x00000002, 0x00000002,
0x00000202, 0x00000202, 0x00000002, 0x00000002, 0x00000202,
0x00000202,
};
private static final int initPermLeftD[] = {
private static final int[] initPermLeftD = {
0x00000000, 0x02000000, 0x00000000, 0x02000000, 0x00020000,
0x02020000, 0x00020000, 0x02020000, 0x00000000, 0x02000000,
0x00000000, 0x02000000, 0x00020000, 0x02020000, 0x00020000,
0x02020000,
};
private static final int initPermRightD[] = {
private static final int[] initPermRightD = {
0x00000000, 0x00000000, 0x02000000, 0x02000000, 0x00000000,
0x00000000, 0x02000000, 0x02000000, 0x00020000, 0x00020000,
0x02020000, 0x02020000, 0x00020000, 0x00020000, 0x02020000,
0x02020000,
};
private static final int initPermLeftE[] = {
private static final int[] initPermLeftE = {
0x00000000, 0x00000100, 0x00000000, 0x00000100, 0x00000001,
0x00000101, 0x00000001, 0x00000101, 0x00000000, 0x00000100,
0x00000000, 0x00000100, 0x00000001, 0x00000101, 0x00000001,
0x00000101,
};
private static final int initPermRightE[] = {
private static final int[] initPermRightE = {
0x00000000, 0x00000000, 0x00000100, 0x00000100, 0x00000000,
0x00000000, 0x00000100, 0x00000100, 0x00000001, 0x00000001,
0x00000101, 0x00000101, 0x00000001, 0x00000001, 0x00000101,
0x00000101,
};
private static final int initPermLeftF[] = {
private static final int[] initPermLeftF = {
0x00000000, 0x01000000, 0x00000000, 0x01000000, 0x00010000,
0x01010000, 0x00010000, 0x01010000, 0x00000000, 0x01000000,
0x00000000, 0x01000000, 0x00010000, 0x01010000, 0x00010000,
0x01010000,
};
private static final int initPermRightF[] = {
private static final int[] initPermRightF = {
0x00000000, 0x00000000, 0x01000000, 0x01000000, 0x00000000,
0x00000000, 0x01000000, 0x01000000, 0x00010000, 0x00010000,
0x01010000, 0x01010000, 0x00010000, 0x00010000, 0x01010000,
@ -586,7 +586,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
void cipherBlock(byte[] in, int inOffset, byte[] out, int outOffset) {
byte key[];
byte[] key;
int temp;
int i, j;
int offset;
@ -638,7 +638,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
}
private static void perm(int left, int right,
byte out[], int offset) {
byte[] out, int offset) {
int low, high, temp;
temp = left;
@ -687,7 +687,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
}
private static int initialPermutationLeft(byte block[], int offset) {
private static int initialPermutationLeft(byte[] block, int offset) {
int l;
l = initPermLeft1[block[offset] & 0xf];
@ -709,7 +709,7 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
return l;
}
private static int initialPermutationRight(byte block[], int offset) {
private static int initialPermutationRight(byte[] block, int offset) {
int l;
l = initPermRight1[block[offset] & 0xf];
@ -731,9 +731,9 @@ class DESCrypt extends SymmetricCipher implements DESConstants {
return l;
}
void expandKey(byte key[]) {
void expandKey(byte[] key) {
int octet;
byte ek[] = new byte[128];
byte[] ek = new byte[128];
octet = key[0];
if ((octet & 0x80) != 0) {

4
src/java.base/share/classes/com/sun/crypto/provider/DESKeyFactory.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -104,7 +104,7 @@ public final class DESKeyFactory extends SecretKeyFactorySpi {
try {
if ((key instanceof SecretKey)
if ((key != null)
&& (key.getAlgorithm().equalsIgnoreCase("DES"))
&& (key.getFormat().equalsIgnoreCase("RAW"))) {

4
src/java.base/share/classes/com/sun/crypto/provider/DESedeKeyFactory.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -103,7 +103,7 @@ public final class DESedeKeyFactory extends SecretKeyFactorySpi {
throws InvalidKeySpecException {
try {
if ((key instanceof SecretKey)
if ((key != null)
&& (key.getAlgorithm().equalsIgnoreCase("DESede"))
&& (key.getFormat().equalsIgnoreCase("RAW"))) {

4
src/java.base/share/classes/com/sun/crypto/provider/DESedeKeyGenerator.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -130,7 +130,7 @@ public final class DESedeKeyGenerator extends KeyGeneratorSpi {
java.util.Arrays.fill(tmpkey, (byte)0x00);
}
DESedeKey desEdeKey = null;
DESedeKey desEdeKey;
try {
desEdeKey = new DESedeKey(rawkey);
} catch (InvalidKeyException ike) {

15
src/java.base/share/classes/com/sun/crypto/provider/DESedeWrapCipher.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2004, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2004, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -137,13 +137,13 @@ public final class DESedeWrapCipher extends CipherSpi {
*/
protected int engineGetOutputSize(int inputLen) {
// can only return an upper-limit if not initialized yet.
int result = 0;
int result;
if (decrypting) {
result = inputLen - 16; // CHECKSUM_LEN + IV_LEN;
} else {
result = Math.addExact(inputLen, 16);
}
return (result < 0? 0:result);
return (Math.max(result, 0));
}
/**
@ -210,7 +210,7 @@ public final class DESedeWrapCipher extends CipherSpi {
AlgorithmParameterSpec params,
SecureRandom random)
throws InvalidKeyException, InvalidAlgorithmParameterException {
byte[] currIv = null;
byte[] currIv;
if (opmode == Cipher.WRAP_MODE) {
decrypting = false;
if (params == null) {
@ -380,7 +380,7 @@ public final class DESedeWrapCipher extends CipherSpi {
/**
* Returns the parameters used with this cipher.
* Note that null maybe returned if this cipher does not use any
* parameters or when it has not be set, e.g. initialized with
* parameters or when it has not been set, e.g. initialized with
* UNWRAP_MODE but wrapped key data has not been given.
*
* @return the parameters used with this cipher; can be null.
@ -556,9 +556,8 @@ public final class DESedeWrapCipher extends CipherSpi {
buffer2, 0);
int keyValLen = buffer2.length - CHECKSUM_LEN;
byte[] cks = getChecksum(buffer2, 0, keyValLen);
int offset = keyValLen;
for (int i = 0; i < CHECKSUM_LEN; i++) {
if (buffer2[offset + i] != cks[i]) {
if (buffer2[keyValLen + i] != cks[i]) {
throw new InvalidKeyException("Checksum comparison failed");
}
}
@ -588,7 +587,7 @@ public final class DESedeWrapCipher extends CipherSpi {
return getChecksum(in, 0, in.length);
}
private static final byte[] getChecksum(byte[] in, int offset, int len) {
MessageDigest md = null;
MessageDigest md;
try {
md = MessageDigest.getInstance("SHA1");
} catch (NoSuchAlgorithmException nsae) {

20
src/java.base/share/classes/com/sun/crypto/provider/DHKEM.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -24,21 +24,23 @@
*/
package com.sun.crypto.provider;
import sun.security.jca.JCAUtil;
import sun.security.ssl.HKDF;
import sun.security.util.*;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.*;
import java.security.interfaces.ECKey;
import java.security.interfaces.ECPublicKey;
import java.security.interfaces.XECKey;
import java.security.interfaces.XECPublicKey;
import java.security.spec.*;
import java.util.Arrays;
import java.util.Objects;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import sun.security.jca.JCAUtil;
import sun.security.ssl.HKDF;
import sun.security.util.*;
// Implementing DHKEM defined inside https://www.rfc-editor.org/rfc/rfc9180.html,
// without the AuthEncap and AuthDecap functions

30
src/java.base/share/classes/com/sun/crypto/provider/DHKeyAgreement.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,23 +25,15 @@
package com.sun.crypto.provider;
import java.util.*;
import java.lang.*;
import java.math.BigInteger;
import java.security.AccessController;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.PrivilegedAction;
import java.security.ProviderException;
import java.security.*;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.InvalidKeySpecException;
import java.util.Arrays;
import javax.crypto.KeyAgreementSpi;
import javax.crypto.ShortBufferException;
import javax.crypto.SecretKey;
import javax.crypto.spec.*;
import javax.crypto.ShortBufferException;
import javax.crypto.spec.DHParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.security.util.KeyUtil;
@ -180,7 +172,7 @@ extends KeyAgreementSpi {
* @param key the key for this phase. For example, in the case of
* Diffie-Hellman between 2 parties, this would be the other party's
* Diffie-Hellman public key.
* @param lastPhase flag which indicates whether or not this is the last
* @param lastPhase flag which indicates if this is the last
* phase of this key agreement.
*
* @return the (intermediate) key resulting from this phase, or null if
@ -227,7 +219,7 @@ extends KeyAgreementSpi {
// intermediate secret, in which case we wrap it into a
// Diffie-Hellman public key object and return it.
generateSecret = true;
if (lastPhase == false) {
if (!lastPhase) {
byte[] intermediate = engineGenerateSecret();
return new DHPublicKey(new BigInteger(1, intermediate),
init_p, init_g);
@ -293,7 +285,7 @@ extends KeyAgreementSpi {
protected int engineGenerateSecret(byte[] sharedSecret, int offset)
throws IllegalStateException, ShortBufferException
{
if (generateSecret == false) {
if (!generateSecret) {
throw new IllegalStateException
("Key agreement has not been completed yet");
}
@ -413,9 +405,7 @@ extends KeyAgreementSpi {
int keysize = secret.length;
if (keysize >= BlowfishConstants.BLOWFISH_MAX_KEYSIZE)
keysize = BlowfishConstants.BLOWFISH_MAX_KEYSIZE;
SecretKeySpec skey = new SecretKeySpec(secret, 0, keysize,
"Blowfish");
return skey;
return new SecretKeySpec(secret, 0, keysize, "Blowfish");
} else if (algorithm.equalsIgnoreCase("AES")) {
// AES
int keysize = secret.length;

5
src/java.base/share/classes/com/sun/crypto/provider/DHKeyPairGenerator.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -28,11 +28,10 @@ package com.sun.crypto.provider;
import java.math.BigInteger;
import java.security.*;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.InvalidParameterSpecException;
import javax.crypto.spec.DHParameterSpec;
import javax.crypto.spec.DHGenParameterSpec;
import sun.security.provider.ParameterCache;
import static sun.security.util.SecurityProviderConstants.DEF_DH_KEY_SIZE;
import static sun.security.util.SecurityProviderConstants.getDefDHPrivateExpSize;

6
src/java.base/share/classes/com/sun/crypto/provider/ElectronicCodeBook.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -27,9 +27,9 @@ package com.sun.crypto.provider;
import java.security.InvalidKeyException;
import java.security.ProviderException;
import sun.security.util.ArrayUtil;
import java.util.Objects;
import jdk.internal.vm.annotation.IntrinsicCandidate;
import sun.security.util.ArrayUtil;
/**
* This class represents ciphers in electronic codebook (ECB) mode.

6
src/java.base/share/classes/com/sun/crypto/provider/FeedbackCipher.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -157,7 +157,7 @@ abstract class FeedbackCipher {
*/
int encryptFinal(byte[] plain, int plainOffset, int plainLen,
byte[] cipher, int cipherOffset)
throws IllegalBlockSizeException, ShortBufferException {
throws IllegalBlockSizeException {
return encrypt(plain, plainOffset, plainLen, cipher, cipherOffset);
}
/**
@ -199,7 +199,7 @@ abstract class FeedbackCipher {
*/
int decryptFinal(byte[] cipher, int cipherOffset, int cipherLen,
byte[] plain, int plainOffset)
throws IllegalBlockSizeException, ShortBufferException {
throws IllegalBlockSizeException {
return decrypt(cipher, cipherOffset, cipherLen, plain, plainOffset);
}
}

5
src/java.base/share/classes/com/sun/crypto/provider/GCTR.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2013, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2013, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -79,8 +79,7 @@ final class GCTR extends CounterMode implements GCM {
ByteBuffer buf = ByteBuffer.wrap(counter, counter.length - 4, 4);
buf.order(ByteOrder.BIG_ENDIAN);
long ctr32 = 0xFFFFFFFFL & buf.getInt();
long blocksLeft = (1L << 32) - ctr32;
return blocksLeft;
return (1L << 32) - ctr32;
}
private void checkBlock() {

7
src/java.base/share/classes/com/sun/crypto/provider/GHASH.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2013, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2013, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -190,9 +190,8 @@ final class GHASH implements Cloneable, GCM {
// If ct is a direct bytebuffer, send it directly to the intrinsic
if (ct.isDirect()) {
int processed = inLen;
processBlocksDirect(ct, inLen);
return processed;
return inLen;
} else if (!ct.isReadOnly()) {
// If a non-read only heap bytebuffer, use the array update method
int processed = update(ct.array(),
@ -273,7 +272,7 @@ final class GHASH implements Cloneable, GCM {
/*
* This is an intrinsified method. The method's argument list must match
* the hotspot signature. This method and methods called by it, cannot
* throw exceptions or allocate arrays as it will breaking intrinsics
* throw exceptions or allocate arrays as it will break intrinsics.
*/
@IntrinsicCandidate
private static void processBlocks(byte[] data, int inOfs, int blocks,

34
src/java.base/share/classes/com/sun/crypto/provider/GaloisCounterMode.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2013, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2013, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,38 +25,24 @@
package com.sun.crypto.provider;
import jdk.internal.access.JavaNioAccess;
import jdk.internal.access.SharedSecrets;
import jdk.internal.misc.Unsafe;
import sun.nio.ch.DirectBuffer;
import sun.security.jca.JCAUtil;
import sun.security.util.ArrayUtil;
import javax.crypto.AEADBadTagException;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.CipherSpi;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;
import javax.crypto.spec.GCMParameterSpec;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.security.AlgorithmParameters;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.ProviderException;
import java.security.SecureRandom;
import java.security.*;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.InvalidParameterSpecException;
import java.util.Arrays;
import javax.crypto.*;
import javax.crypto.spec.GCMParameterSpec;
import jdk.internal.access.JavaNioAccess;
import jdk.internal.access.SharedSecrets;
import jdk.internal.misc.Unsafe;
import jdk.internal.vm.annotation.IntrinsicCandidate;
import sun.nio.ch.DirectBuffer;
import sun.security.jca.JCAUtil;
import sun.security.util.ArrayUtil;
/**
* This class represents ciphers in GaloisCounter (GCM) mode.

27
src/java.base/share/classes/com/sun/crypto/provider/HmacCore.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2020, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,16 +25,12 @@
package com.sun.crypto.provider;
import java.util.Arrays;
import java.nio.ByteBuffer;
import java.security.*;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Arrays;
import javax.crypto.MacSpi;
import javax.crypto.SecretKey;
import java.security.*;
import java.security.spec.*;
import sun.security.x509.AlgorithmId;
/**
* This class constitutes the core of HMAC-<MD> algorithms, where
@ -87,8 +83,7 @@ abstract class HmacCore extends MacSpi implements Cloneable {
break;
}
}
} catch (NoSuchAlgorithmException nsae) {
continue;
} catch (NoSuchAlgorithmException ignored) {
}
}
if (md == null) {
@ -169,7 +164,7 @@ abstract class HmacCore extends MacSpi implements Cloneable {
* @param input the input byte to be processed.
*/
protected void engineUpdate(byte input) {
if (first == true) {
if (first) {
// compute digest for 1st pass; start with inner pad
md.update(k_ipad);
first = false;
@ -187,8 +182,8 @@ abstract class HmacCore extends MacSpi implements Cloneable {
* @param offset the offset in <code>input</code> where the input starts.
* @param len the number of bytes to process.
*/
protected void engineUpdate(byte input[], int offset, int len) {
if (first == true) {
protected void engineUpdate(byte[] input, int offset, int len) {
if (first) {
// compute digest for 1st pass; start with inner pad
md.update(k_ipad);
first = false;
@ -205,7 +200,7 @@ abstract class HmacCore extends MacSpi implements Cloneable {
* @param input the input byte buffer.
*/
protected void engineUpdate(ByteBuffer input) {
if (first == true) {
if (first) {
// compute digest for 1st pass; start with inner pad
md.update(k_ipad);
first = false;
@ -221,7 +216,7 @@ abstract class HmacCore extends MacSpi implements Cloneable {
* @return the HMAC result.
*/
protected byte[] engineDoFinal() {
if (first == true) {
if (first) {
// compute digest for 1st pass; start with inner pad
md.update(k_ipad);
} else {
@ -250,7 +245,7 @@ abstract class HmacCore extends MacSpi implements Cloneable {
* HMAC was initialized with.
*/
protected void engineReset() {
if (first == false) {
if (!first) {
md.reset();
first = true;
}

9
src/java.base/share/classes/com/sun/crypto/provider/HmacMD5.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,12 +25,7 @@
package com.sun.crypto.provider;
import java.nio.ByteBuffer;
import javax.crypto.MacSpi;
import javax.crypto.SecretKey;
import java.security.*;
import java.security.spec.*;
import java.security.NoSuchAlgorithmException;
/**
* This is an implementation of the HMAC-MD5 algorithm.

5
src/java.base/share/classes/com/sun/crypto/provider/HmacMD5KeyGenerator.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,9 +25,8 @@
package com.sun.crypto.provider;
import java.security.SecureRandom;
import java.security.InvalidParameterException;
import java.security.InvalidAlgorithmParameterException;
import java.security.SecureRandom;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Arrays;
import javax.crypto.KeyGeneratorSpi;

9
src/java.base/share/classes/com/sun/crypto/provider/HmacSHA1.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,12 +25,7 @@
package com.sun.crypto.provider;
import java.nio.ByteBuffer;
import javax.crypto.MacSpi;
import javax.crypto.SecretKey;
import java.security.*;
import java.security.spec.*;
import java.security.NoSuchAlgorithmException;
/**
* This is an implementation of the HMAC-SHA1 algorithm.

5
src/java.base/share/classes/com/sun/crypto/provider/HmacSHA1KeyGenerator.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1999, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,9 +25,8 @@
package com.sun.crypto.provider;
import java.security.SecureRandom;
import java.security.InvalidParameterException;
import java.security.InvalidAlgorithmParameterException;
import java.security.SecureRandom;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Arrays;
import javax.crypto.KeyGeneratorSpi;

5
src/java.base/share/classes/com/sun/crypto/provider/ISO10126Padding.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -119,7 +119,6 @@ final class ISO10126Padding implements Padding {
* @return the length of the padding
*/
public int padLength(int len) {
int paddingOctet = blockSize - (len % blockSize);
return paddingOctet;
return blockSize - (len % blockSize);
}
}

14
src/java.base/share/classes/com/sun/crypto/provider/JceKeyStore.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -75,7 +75,7 @@ public final class JceKeyStore extends KeyStoreSpi {
Date date; // the creation date of this entry
byte[] protectedKey;
Certificate[] chain;
};
}
// Secret key
private static final class SecretKeyEntry {
@ -93,7 +93,7 @@ public final class JceKeyStore extends KeyStoreSpi {
private static final class TrustedCertEntry {
Date date; // the creation date of this entry
Certificate cert;
};
}
/**
* Private keys and certificates are stored in a hashtable.
@ -119,7 +119,7 @@ public final class JceKeyStore extends KeyStoreSpi {
public Key engineGetKey(String alias, char[] password)
throws NoSuchAlgorithmException, UnrecoverableKeyException
{
Key key = null;
Key key;
Object entry = entries.get(alias.toLowerCase(Locale.ENGLISH));
@ -652,7 +652,7 @@ public final class JceKeyStore extends KeyStoreSpi {
* the keystore (such as deleting or modifying key or
* certificate entries).
*/
byte digest[] = md.digest();
byte[] digest = md.digest();
dos.write(digest);
dos.flush();
@ -691,8 +691,8 @@ public final class JceKeyStore extends KeyStoreSpi {
MessageDigest md = null;
CertificateFactory cf = null;
Hashtable<String, CertificateFactory> cfs = null;
ByteArrayInputStream bais = null;
byte[] encoded = null;
ByteArrayInputStream bais;
byte[] encoded;
int trustedKeyCount = 0, privateKeyCount = 0, secretKeyCount = 0;
if (stream == null)

10
src/java.base/share/classes/com/sun/crypto/provider/KWUtil.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2021, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -26,10 +26,6 @@
package com.sun.crypto.provider;
import java.util.Arrays;
import java.security.*;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
/**
* This class acts as the base class for AES KeyWrap algorithms as defined
@ -58,7 +54,7 @@ class KWUtil {
("Invalid data length for W: " + inLen);
assert(icvIn.length == SEMI_BLKSIZE) : "Invalid ICV buffer size";
// overwrite the first block of in with the icv semiblock
// overwrite the first block of in with the icv semi-block
System.arraycopy(icvIn, 0, in, 0, SEMI_BLKSIZE);
int n = inLen / SEMI_BLKSIZE - 1;
@ -93,7 +89,7 @@ class KWUtil {
* data until the initial value and padding bytes are verified.
* @param in input bytes, i.e. the to-be-processed data
* @param inLen length of the to-be-processed bytes
* @param ivOut buffer for holding the recovered ICV semiblock
* @param ivOut buffer for holding the recovered ICV semi-block
* @param cipher the initialized cipher object used
* @return the recovered data length, i.e. {@code (inLen - icvOut.length)}
*/

6
src/java.base/share/classes/com/sun/crypto/provider/KeyProtector.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1998, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -98,7 +98,7 @@ final class KeyProtector {
iterationCount > MAX_ITERATION_COUNT) {
iterationCount = DEFAULT_ITERATION_COUNT;
}
} catch (NumberFormatException e) {}
} catch (NumberFormatException ignored) {}
}
ITERATION_COUNT = iterationCount;
}
@ -369,7 +369,7 @@ final class KeyProtector {
sKey = new PBEKey(pbeKeySpec, "PBEWithMD5AndTripleDES");
pbeKeySpec.clearPassword();
SealedObjectForKeyProtector soForKeyProtector = null;
SealedObjectForKeyProtector soForKeyProtector;
if (!(so instanceof SealedObjectForKeyProtector)) {
soForKeyProtector = new SealedObjectForKeyProtector(so);
} else {

20
src/java.base/share/classes/com/sun/crypto/provider/KeyWrapCipher.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2004, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2004, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -285,7 +285,7 @@ abstract class KeyWrapCipher extends CipherSpi {
padLen = SEMI_BLKSIZE - n;
}
}
// then add the first semiblock and padLen to result
// then add the first semi-block and padLen to result
result = Math.addExact(result, SEMI_BLKSIZE + padLen);
} else {
result = inLen - SEMI_BLKSIZE;
@ -339,7 +339,7 @@ abstract class KeyWrapCipher extends CipherSpi {
protected void engineInit(int opmode, Key key, SecureRandom random)
throws InvalidKeyException {
try {
implInit(opmode, key, (byte[])null, random);
implInit(opmode, key, null, random);
} catch (InvalidAlgorithmParameterException iae) {
// should never happen
throw new AssertionError(iae);
@ -394,9 +394,9 @@ abstract class KeyWrapCipher extends CipherSpi {
byte[] iv = null;
if (params != null) {
try {
AlgorithmParameterSpec spec =
IvParameterSpec spec =
params.getParameterSpec(IvParameterSpec.class);
iv = ((IvParameterSpec)spec).getIV();
iv = spec.getIV();
} catch (InvalidParameterSpecException ispe) {
throw new InvalidAlgorithmParameterException(
"Only IvParameterSpec is accepted");
@ -462,7 +462,7 @@ abstract class KeyWrapCipher extends CipherSpi {
if (inLen <= 0) return;
if (opmode == Cipher.ENCRYPT_MODE && dataIdx == 0) {
// the first semiblock is for iv, store data after it
// the first semi-block is for iv, store data after it
dataIdx = SEMI_BLKSIZE;
}
store(in, inOfs, inLen);
@ -595,8 +595,8 @@ abstract class KeyWrapCipher extends CipherSpi {
}
// helper routine for in-place encryption.
// 'inBuf' = semiblock | plain text | extra bytes if padding is used
// 'inLen' = semiblock length + plain text length
// 'inBuf' = semi-block | plain text | extra bytes if padding is used
// 'inLen' = semi-block length + plain text length
private int helperEncrypt(byte[] inBuf, int inLen)
throws IllegalBlockSizeException, ShortBufferException {
@ -646,7 +646,7 @@ abstract class KeyWrapCipher extends CipherSpi {
*/
@Override
protected AlgorithmParameters engineGetParameters() {
AlgorithmParameters params = null;
AlgorithmParameters params;
byte[] iv = cipher.getIV();
if (iv == null) {
@ -711,7 +711,7 @@ abstract class KeyWrapCipher extends CipherSpi {
// output size is known, allocate output buffer
byte[] out = new byte[engineGetOutputSize(encoded.length)];
// reserve the first semiblock and do not write data
// reserve the first semi-block and do not write data
int len = SEMI_BLKSIZE;
System.arraycopy(encoded, 0, out, len, encoded.length);
len += encoded.length;

12
src/java.base/share/classes/com/sun/crypto/provider/OAEPParameters.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -225,11 +225,9 @@ public final class OAEPParameters extends AlgorithmParametersSpi {
}
protected String engineToString() {
StringBuilder sb = new StringBuilder();
sb.append("MD: " + mdName + "\n");
sb.append("MGF: MGF1" + mgfSpec.getDigestAlgorithm() + "\n");
sb.append("PSource: PSpecified " +
(p.length==0? "":Debug.toHexString(new BigInteger(p))) + "\n");
return sb.toString();
return "MD: " + mdName + "\n" +
"MGF: MGF1" + mgfSpec.getDigestAlgorithm() + "\n" +
"PSource: PSpecified " +
(p.length == 0 ? "" : Debug.toHexString(new BigInteger(p))) + "\n";
}
}

4
src/java.base/share/classes/com/sun/crypto/provider/OutputFeedback.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -53,7 +53,7 @@ final class OutputFeedback extends FeedbackCipher {
private final byte[] register;
/*
* number of bytes for each stream unit, defaults to the blocksize
* number of bytes for each stream unit, defaults to the block size
* of the embedded cipher
*/
private final int numBytes;

4
src/java.base/share/classes/com/sun/crypto/provider/PBEKeyFactory.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -261,7 +261,7 @@ abstract class PBEKeyFactory extends SecretKeyFactorySpi {
*/
protected KeySpec engineGetKeySpec(SecretKey key, Class<?> keySpecCl)
throws InvalidKeySpecException {
if ((key instanceof SecretKey)
if ((key != null)
&& (validTypes.contains(key.getAlgorithm().toUpperCase(Locale.ENGLISH)))
&& (key.getFormat().equalsIgnoreCase("RAW"))) {

6
src/java.base/share/classes/com/sun/crypto/provider/PBES1Core.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2002, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -161,7 +161,7 @@ final class PBES1Core {
* does not use any parameters.
*/
AlgorithmParameters getParameters() {
AlgorithmParameters params = null;
AlgorithmParameters params;
if (salt == null) {
salt = new byte[8];
SunJCE.getRandom().nextBytes(salt);
@ -303,7 +303,7 @@ final class PBES1Core {
// Concatenate the output from each digest round with the
// password, and use the result as the input to the next digest
// operation.
byte[] toBeHashed = null;
byte[] toBeHashed;
result = new byte[DESedeKeySpec.DES_EDE_KEY_LEN +
DESConstants.DES_BLOCK_SIZE];
for (i = 0; i < 2; i++) {

20
src/java.base/share/classes/com/sun/crypto/provider/PBES2Parameters.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2012, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -131,8 +131,8 @@ abstract class PBES2Parameters extends AlgorithmParametersSpi {
PBES2Parameters(String pbes2AlgorithmName) throws NoSuchAlgorithmException {
int and;
String kdfAlgo = null;
String cipherAlgo = null;
String kdfAlgo;
String cipherAlgo;
// Extract the KDF and encryption algorithm names
this.pbes2AlgorithmName = pbes2AlgorithmName;
@ -210,9 +210,6 @@ abstract class PBES2Parameters extends AlgorithmParametersSpi {
protected void engineInit(byte[] encoded)
throws IOException
{
String kdfAlgo = null;
String cipherAlgo = null;
DerValue pBES2_params = new DerValue(encoded);
if (pBES2_params.tag != DerValue.tag_Sequence) {
throw new IOException("PBE parameter parsing error: "
@ -231,16 +228,15 @@ abstract class PBES2Parameters extends AlgorithmParametersSpi {
kdf = pBES2_params.data.getDerValue();
}
kdfAlgo = parseKDF(kdf);
String kdfAlgo = parseKDF(kdf);
if (pBES2_params.tag != DerValue.tag_Sequence) {
throw new IOException("PBE parameter parsing error: "
+ "not an ASN.1 SEQUENCE tag");
}
cipherAlgo = parseES(pBES2_params.data.getDerValue());
String cipherAlgo = parseES(pBES2_params.data.getDerValue());
this.pbes2AlgorithmName = new StringBuilder().append("PBEWith")
.append(kdfAlgo).append("And").append(cipherAlgo).toString();
this.pbes2AlgorithmName = "PBEWith" + kdfAlgo + "And" + cipherAlgo;
}
@SuppressWarnings("deprecation")
@ -305,7 +301,7 @@ abstract class PBES2Parameters extends AlgorithmParametersSpi {
@SuppressWarnings("deprecation")
private String parseES(DerValue encryptionScheme) throws IOException {
String cipherAlgo = null;
String cipherAlgo;
cipherAlgo_OID = encryptionScheme.data.getOID();
if (aes128CBC_OID.equals(cipherAlgo_OID)) {
@ -399,7 +395,7 @@ abstract class PBES2Parameters extends AlgorithmParametersSpi {
/*
* Returns a formatted string describing the parameters.
*
* The algorithn name pattern is: "PBEWith<prf>And<encryption>"
* The algorithm name pattern is: "PBEWith<prf>And<encryption>"
* where <prf> is one of: HmacSHA1, HmacSHA224, HmacSHA256, HmacSHA384,
* HmacSHA512, HmacSHA512/224, or HmacSHA512/256 and <encryption> is
* AES with a keysize suffix.

21
src/java.base/share/classes/com/sun/crypto/provider/PBKDF2KeyImpl.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -25,26 +25,29 @@
package com.sun.crypto.provider;
import java.io.*;
import java.lang.ref.Reference;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamException;
import java.lang.ref.Cleaner;
import java.lang.ref.Reference;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.util.Arrays;
import java.util.Locale;
import java.security.MessageDigest;
import java.security.KeyRep;
import java.security.GeneralSecurityException;
import java.security.KeyRep;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.Arrays;
import java.util.Locale;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.PBEKeySpec;
import static java.nio.charset.StandardCharsets.UTF_8;
import jdk.internal.ref.CleanerFactory;
import static java.nio.charset.StandardCharsets.UTF_8;
/**
* This class represents a PBE key derived using PBKDF2 defined
* in PKCS#5 v2.0. meaning that

4
src/java.base/share/classes/com/sun/crypto/provider/PBMAC1Core.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -61,7 +61,7 @@ abstract class PBMAC1Core extends HmacCore {
}
private static PBKDF2Core getKDFImpl(String algo) {
PBKDF2Core kdf = null;
PBKDF2Core kdf;
switch(algo) {
case "HmacSHA1":
kdf = new PBKDF2Core.HmacSHA1();

5
src/java.base/share/classes/com/sun/crypto/provider/PKCS5Padding.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -120,7 +120,6 @@ final class PKCS5Padding implements Padding {
* @return the length of the padding
*/
public int padLength(int len) {
int paddingOctet = blockSize - (len % blockSize);
return paddingOctet;
return blockSize - (len % blockSize);
}
}

12
src/java.base/share/classes/com/sun/crypto/provider/Poly1305.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2018, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -26,16 +26,18 @@
package com.sun.crypto.provider;
import java.nio.ByteBuffer;
import java.security.Key;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.spec.AlgorithmParameterSpec;
import java.util.Arrays;
import java.util.Objects;
import sun.security.util.math.*;
import sun.security.util.math.intpoly.*;
import jdk.internal.vm.annotation.IntrinsicCandidate;
import jdk.internal.vm.annotation.ForceInline;
import jdk.internal.vm.annotation.IntrinsicCandidate;
import sun.security.util.math.IntegerFieldModuloP;
import sun.security.util.math.IntegerModuloP;
import sun.security.util.math.MutableIntegerModuloP;
import sun.security.util.math.intpoly.IntegerPolynomial1305;
/**
* This class represents the Poly1305 function defined in RFC 7539.

4
src/java.base/share/classes/com/sun/crypto/provider/RC2Crypt.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2007, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -108,7 +108,7 @@ final class RC2Crypt extends SymmetricCipher {
static void checkKey(String algorithm, int keyLength)
throws InvalidKeyException {
if (algorithm.equals("RC2") == false) {
if (!algorithm.equals("RC2")) {
throw new InvalidKeyException("Key algorithm must be RC2");
}
if ((keyLength < 5) || (keyLength > 128)) {

7
src/java.base/share/classes/com/sun/crypto/provider/RSACipher.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -33,6 +33,7 @@ import java.security.interfaces.*;
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.InvalidParameterSpecException;
import java.security.spec.MGF1ParameterSpec;
import java.util.Objects;
import javax.crypto.*;
import javax.crypto.spec.PSource;
@ -126,7 +127,7 @@ public final class RSACipher extends CipherSpi {
// modes do not make sense for RSA, but allow ECB
// see JCE spec
protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
if (mode.equalsIgnoreCase("ECB") == false) {
if (!mode.equalsIgnoreCase("ECB")) {
throw new NoSuchAlgorithmException("Unsupported mode " + mode);
}
}
@ -468,7 +469,7 @@ public final class RSACipher extends CipherSpi {
boolean isTlsRsaPremasterSecret =
algorithm.equals("TlsRsaPremasterSecret");
byte[] encoded = null;
byte[] encoded;
update(wrappedKey, 0, wrappedKey.length);
try {

23
src/java.base/share/classes/com/sun/crypto/provider/SslMacCore.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2009, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -26,11 +26,10 @@
package com.sun.crypto.provider;
import java.nio.ByteBuffer;
import javax.crypto.MacSpi;
import javax.crypto.SecretKey;
import java.security.*;
import java.security.spec.AlgorithmParameterSpec;
import javax.crypto.MacSpi;
import javax.crypto.SecretKey;
import static com.sun.crypto.provider.TlsPrfGenerator.genPad;
@ -109,7 +108,7 @@ final class SslMacCore {
* @param input the input byte to be processed.
*/
void update(byte input) {
if (first == true) {
if (first) {
// compute digest for 1st pass; start with inner pad
md.update(secret);
md.update(pad1);
@ -128,8 +127,8 @@ final class SslMacCore {
* @param offset the offset in <code>input</code> where the input starts.
* @param len the number of bytes to process.
*/
void update(byte input[], int offset, int len) {
if (first == true) {
void update(byte[] input, int offset, int len) {
if (first) {
// compute digest for 1st pass; start with inner pad
md.update(secret);
md.update(pad1);
@ -141,7 +140,7 @@ final class SslMacCore {
}
void update(ByteBuffer input) {
if (first == true) {
if (first) {
// compute digest for 1st pass; start with inner pad
md.update(secret);
md.update(pad1);
@ -158,7 +157,7 @@ final class SslMacCore {
* @return the Mac result.
*/
byte[] doFinal() {
if (first == true) {
if (first) {
// compute digest for 1st pass; start with inner pad
md.update(secret);
md.update(pad1);
@ -189,7 +188,7 @@ final class SslMacCore {
* Mac was initialized with.
*/
void reset() {
if (first == false) {
if (!first) {
md.reset();
first = true;
}
@ -211,7 +210,7 @@ final class SslMacCore {
protected void engineUpdate(byte input) {
core.update(input);
}
protected void engineUpdate(byte input[], int offset, int len) {
protected void engineUpdate(byte[] input, int offset, int len) {
core.update(input, offset, len);
}
protected void engineUpdate(ByteBuffer input) {
@ -244,7 +243,7 @@ final class SslMacCore {
protected void engineUpdate(byte input) {
core.update(input);
}
protected void engineUpdate(byte input[], int offset, int len) {
protected void engineUpdate(byte[] input, int offset, int len) {
core.update(input, offset, len);
}
protected void engineUpdate(ByteBuffer input) {

12
src/java.base/share/classes/com/sun/crypto/provider/TlsKeyMaterialGenerator.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -62,11 +62,11 @@ public final class TlsKeyMaterialGenerator extends KeyGeneratorSpi {
@SuppressWarnings("deprecation")
protected void engineInit(AlgorithmParameterSpec params,
SecureRandom random) throws InvalidAlgorithmParameterException {
if (params instanceof TlsKeyMaterialParameterSpec == false) {
if (!(params instanceof TlsKeyMaterialParameterSpec)) {
throw new InvalidAlgorithmParameterException(MSG);
}
this.spec = (TlsKeyMaterialParameterSpec)params;
if ("RAW".equals(spec.getMasterSecret().getFormat()) == false) {
if (!"RAW".equals(spec.getMasterSecret().getFormat())) {
throw new InvalidAlgorithmParameterException(
"Key format must be RAW");
}
@ -105,8 +105,6 @@ public final class TlsKeyMaterialGenerator extends KeyGeneratorSpi {
SecretKey clientMacKey = null;
SecretKey serverMacKey = null;
SecretKey clientCipherKey = null;
SecretKey serverCipherKey = null;
IvParameterSpec clientIv = null;
IvParameterSpec serverIv = null;
@ -194,8 +192,10 @@ public final class TlsKeyMaterialGenerator extends KeyGeneratorSpi {
System.arraycopy(keyBlock, ofs, serverKeyBytes, 0, keyLength);
ofs += keyLength;
SecretKey clientCipherKey;
SecretKey serverCipherKey;
try {
if (isExportable == false) {
if (!isExportable) {
// cipher keys
clientCipherKey = new SecretKeySpec(clientKeyBytes, alg);
serverCipherKey = new SecretKeySpec(serverKeyBytes, alg);

8
src/java.base/share/classes/com/sun/crypto/provider/TlsPrfGenerator.java
View file

@ -1,5 +1,5 @@
/*
* Copyright (c) 2005, 2021, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -132,12 +132,12 @@ abstract class TlsPrfGenerator extends KeyGeneratorSpi {
@SuppressWarnings("deprecation")
protected void engineInit(AlgorithmParameterSpec params,
SecureRandom random) throws InvalidAlgorithmParameterException {
if (params instanceof TlsPrfParameterSpec == false) {
if (!(params instanceof TlsPrfParameterSpec)) {
throw new InvalidAlgorithmParameterException(MSG);
}
this.spec = (TlsPrfParameterSpec)params;
SecretKey key = spec.getSecret();
if ((key != null) && ("RAW".equals(key.getFormat()) == false)) {
if ((key != null) && (!"RAW".equals(key.getFormat()))) {
throw new InvalidAlgorithmParameterException(
"Key encoding format must be RAW");
}
@ -378,7 +378,7 @@ abstract class TlsPrfGenerator extends KeyGeneratorSpi {
* TLS 1.2 uses a different hash algorithm than 1.0/1.1 for the PRF
* calculations. As of 2010, there is no PKCS11-level support for TLS
* 1.2 PRF calculations, and no known OS's have an internal variant
* we could use. Therefore for TLS 1.2, we are updating JSSE to request
* we could use. Therefore, for TLS 1.2, we are updating JSSE to request
* a different provider algorithm: "SunTls12Prf". If we reused the
* name "SunTlsPrf", the PKCS11 provider would need be updated to
* fail correctly when presented with the wrong version number