@Nested
    @DisplayName("Header Constants")
    class HeaderConstants {

        @Test
        @DisplayName("SMB2 header length should be 64 bytes")
        void testSmb2HeaderLength() {
            assertEquals(64, Smb2Constants.SMB2_HEADER_LENGTH, "SMB2 header must be exactly 64 bytes");
        }
    }

    @Nested
    @DisplayName("Negotiation Constants")
    class NegotiationConstants {

        @Test

		logger.CriticalIf(context.Background(), errOutOfEntropy)
	}
	return iv
}

// SealedKey represents a sealed object key. It can be stored
// at an untrusted location.
type SealedKey struct {
	Key       [64]byte // The encrypted and authenticated object-key.
	IV        [32]byte // The random IV used to encrypt the object-key.
	Algorithm string   // The sealing algorithm used to encrypt the object key.
}

This package does not support disk spanning.

A note about ZIP64:

To be backwards compatible the FileHeader has both 32 and 64 bit Size
fields. The 64 bit fields will always contain the correct value and
for normal archives both fields will be the same. For files requiring
the ZIP64 format the 32 bit fields will be 0xffffffff and the 64 bit
fields must be used instead.

[ZIP specification]: https://support.pkware.com/pkzip/appnote
*/
package zip

	"log"
)

func bytesToPrivateKey(priv []byte) (*rsa.PrivateKey, error) {
	// Try PEM
	if block, _ := pem.Decode(priv); block != nil {
		return x509.ParsePKCS1PrivateKey(block.Bytes)
	}
	// Try base 64
	dst := make([]byte, base64.StdEncoding.DecodedLen(len(priv)))
	if n, err := base64.StdEncoding.Decode(dst, priv); err == nil {
		return x509.ParsePKCS1PrivateKey(dst[:n])
	}
	// Try Raw, return error

    int LOGON_RESOURCE_GROUPS = 0x200;

    /**
     * Kerberos salt type for MD5 checksums.
     */
    int MD5_KRB_SALT = 17;
    /**
     * MD5 block length in bytes.
     */
    int MD5_BLOCK_LENGTH = 64;

	if b {
		*t |= other
	}
}

// Mask returns the mask as a uint64.
func (t Mask) Mask() uint64 {
	return uint64(t)
}

// Maskable implementations must return their mask as a 64 bit uint.
type Maskable interface {
	Mask() uint64

		return x, nil
	case int64:
		return float64(x), nil
	case string:
		f, err := strconv.ParseFloat(strings.TrimSpace(x), 64)
		if err != nil {
			return 0, errCastFailure("could not parse as float")
		}
		return f, nil
	case []byte:
		f, err := strconv.ParseFloat(strings.TrimSpace(string(x)), 64)
		if err != nil {
			return 0, errCastFailure("could not parse as float")
		}
		return f, nil
	default:

@SuppressWarnings("deprecation") // We still need to test our deprecated APIs.
@NullUnmarked
enum HashFunctionEnum {
  ADLER32(adler32()),
  CRC32(crc32()),
  GOOD_FAST_HASH_32(goodFastHash(32)),
  GOOD_FAST_HASH_64(goodFastHash(64)),
  GOOD_FAST_HASH_128(goodFastHash(128)),
  GOOD_FAST_HASH_256(goodFastHash(256)),
  MD5(md5()),
  MURMUR3_128(murmur3_128()),
  MURMUR3_32(murmur3_32()),
  MURMUR3_32_FIXED(murmur3_32_fixed()),
  SHA1(sha1()),

		{"a", 'ӆ', -1},
		{"  ӆ", 'ӆ', 2},
		{"  a", 'ӆ', -1},
		{strings.Repeat("ц", 64) + "ӆ", 'ӆ', 128}, // test cutover
		{strings.Repeat("ц", 64), 'ӆ', -1},

		// 3 bytes
		{"Ꚁ", 'Ꚁ', 0},
		{"a", 'Ꚁ', -1},
		{"  Ꚁ", 'Ꚁ', 2},
		{"  a", 'Ꚁ', -1},
		{strings.Repeat("Ꙁ", 64) + "Ꚁ", 'Ꚁ', 192}, // test cutover
		{strings.Repeat("Ꙁ", 64) + "Ꚁ", '䚀', -1},  // 'Ꚁ' and '䚀' share the same last two bytes

		// 4 bytes

				return n, cr.err
			}
			break
		}

		// Manually deserialize the size since AWS specified
		// the chunk size to be of variable width. In particular,
		// a size of 16 is encoded as `10` while a size of 64 KB
		// is `10000`.
		switch {
		case b >= '0' && b <= '9':
			size = size<<4 | int(b-'0')
		case b >= 'a' && b <= 'f':
			size = size<<4 | int(b-('a'-10))
		case b >= 'A' && b <= 'F':