final DerivationParameters param = new KDFCounterParameters(sessionKey, null /* prefix */, suffix /* suffix */, r /* r */);
        gen.init(param);

        final byte[] derived = new byte[16];
        gen.generateBytes(derived, 0, 16);
        return derived;
    }

    /**
     * @param string
     * @return null terminated ASCII bytes
     */
    private static byte[] toCBytes(final String string) {

            uuid.clock_seq_low = (byte) 0x22;
            uuid.node = new byte[] { (byte) 0xAA, (byte) 0xBB, (byte) 0xCC, (byte) 0xDD, (byte) 0xEE, (byte) 0xFF };

            // Mock the derive method to return a buffer for node encoding
            when(mockNdrBuffer.derive(anyInt())).thenReturn(mockNdrBuffer);

            // When: Encoding the UUID
            uuid.encode(mockNdrBuffer);

            // Then: Verify the encoding sequence

        // Then
        assertFalse(Arrays.equals(signingKey1, signingKey2), "Different session keys should produce different derived keys");
    }

    @Test
    @DisplayName("Should derive unique keys for different preauth values")
    void testDeriveKeys_UniquePreauthValues() {
        // Given
        byte[] preauth1 = new byte[64];

                        Artifact artifact = node.getArtifact();
                        Map<String, String> props = new HashMap<>(artifact.getProperties());
                        ArtifactType derived = derive(parentType, currentType);
                        props.putAll(derived.getProperties());
                        node.setArtifact(artifact.setProperties(props));
                    }
                }
            }

        }

        // Generate salt for key derivation
        this.salt = new byte[SALT_SIZE];
        secureRandom.nextBytes(this.salt);

        // Derive master key from password
        this.masterKey = deriveKey(masterPassword, salt);

        // Clear the master password after use
        Arrays.fill(masterPassword, '\0');
    }

    /**

	"github.com/minio/sio"
)

const (
	// SealAlgorithm is the encryption/sealing algorithm used to derive & seal
	// the key-encryption-key and to en/decrypt the object data.
	SealAlgorithm = "DAREv2-HMAC-SHA256"

	// InsecureSealAlgorithm is the legacy encryption/sealing algorithm used
	// to derive & seal the key-encryption-key and to en/decrypt the object data.

        // TODO: in a moment Maven stop pushing user properties to system properties (and maybe something more)
        // and allow multiple instances per JVM, this may become a pool? derive key based in invokerRequest?
        MavenContext result = residentContext.computeIfAbsent(
                "resident",
                k -> new MavenContext(invokerRequest, false, (MavenOptions)

            ArtifactRepositoryPolicy releases) {
        this.id = id;
        this.url = url;
        this.layout = layout;
        this.snapshots = snapshots;
        this.releases = releases;
        //
        // Derive these from the URL
        //
        this.protocol = protocol(url);
        this.basedir = basedir(url);
    }

    public MavenArtifactRepository(
            String id,
            Path path,

          message.startsWith("Found resumable session") -> Type.Handshake
          message.startsWith("Resuming session") -> Type.Handshake
          message.startsWith("Using PSK to derive early secret") -> Type.Handshake
          else -> Type.Unknown
        }

    override fun toString(): String =
      if (param != null) {
        message + "\n" + param
      } else {
        message
      }

 * implement subtleties of the API improperly.
 *
 * <p><b>Custom implementation</b>: Avoid implementing {@code ListenableFuture} from scratch. If you
 * can't get by with the standard implementations, prefer to derive a new {@code Future} instance
 * with the methods in {@link Futures} or, if necessary, to extend {@link AbstractFuture}.
 *
 * <p>Occasionally, an API will return a plain {@code Future} and it will be impossible to change