diff --git a/cpp/ql/lib/experimental/quantum/OpenSSL/AlgorithmInstances/CipherAlgorithmInstance.qll b/cpp/ql/lib/experimental/quantum/OpenSSL/AlgorithmInstances/CipherAlgorithmInstance.qll index 94251c39b566..23efacae69b7 100644 --- a/cpp/ql/lib/experimental/quantum/OpenSSL/AlgorithmInstances/CipherAlgorithmInstance.qll +++ b/cpp/ql/lib/experimental/quantum/OpenSSL/AlgorithmInstances/CipherAlgorithmInstance.qll @@ -119,7 +119,7 @@ class KnownOpenSslCipherConstantAlgorithmInstance extends OpenSslAlgorithmInstan knownOpenSslConstantToCipherFamilyType(this, result) or not knownOpenSslConstantToCipherFamilyType(this, _) and - result = Crypto::KeyOpAlg::TUnknownKeyOperationAlgorithmType() + result = Crypto::KeyOpAlg::TOtherKeyOperationAlgorithmType() } override OpenSslAlgorithmValueConsumer getAvc() { result = getterCall } diff --git a/java/ql/lib/experimental/quantum/JCA.qll b/java/ql/lib/experimental/quantum/JCA.qll index 6cfe54c5ef8a..8b27409410a3 100644 --- a/java/ql/lib/experimental/quantum/JCA.qll +++ b/java/ql/lib/experimental/quantum/JCA.qll @@ -18,6 +18,8 @@ module JCAModel { abstract class KeyAgreementAlgorithmValueConsumer extends Crypto::AlgorithmValueConsumer { } + abstract class SignatureAlgorithmValueConsumer extends Crypto::AlgorithmValueConsumer { } + // TODO: Verify that the PBEWith% case works correctly bindingset[algo] predicate cipher_names(string algo) { @@ -100,9 +102,21 @@ module JCAModel { ].toUpperCase()) } + /** + * Names that match known signature algorithms. + * https://docs.oracle.com/en/java/javase/25/docs/specs/security/standard-names.html + */ + bindingset[name] + predicate signature_names(string name) { + name.toUpperCase().splitAt("WITH", 1).matches(["RSA%", "ECDSA%", "DSA%"]) + or + name.toUpperCase().matches(["RSASSA-PSS", "ED25519", "ED448", "EDDSA", "ML-DSA%", "HSS/LMS"]) + } + bindingset[name] predicate key_agreement_names(string name) { - name.toUpperCase().matches(["DH", "EDH", "ECDH", "X25519", "X448"].toUpperCase()) + name.toUpperCase() + .matches(["DH", "EDH", "ECDH", "X25519", "X448", "ML-KEM%", "XDH"].toUpperCase()) } bindingset[name] @@ -208,13 +222,46 @@ module JCAModel { bindingset[name] predicate key_agreement_name_to_type_known(Crypto::TKeyAgreementType type, string name) { type = Crypto::DH() and - name.toUpperCase() = "DH" + name.toUpperCase() in ["DH", "XDH"] or type = Crypto::EDH() and name.toUpperCase() = "EDH" or type = Crypto::ECDH() and name.toUpperCase() in ["ECDH", "X25519", "X448"] + or + type = Crypto::OtherKeyAgreementType() and + name.toUpperCase().matches("ML-KEM%") + } + + /** + * Maps a signature algorithm name to its type, if known. + * see https://docs.oracle.com/en/java/javase/25/docs/specs/security/standard-names.html + */ + bindingset[name] + predicate signature_name_to_type_known(Crypto::KeyOpAlg::TAlgorithm type, string name) { + name.toUpperCase().splitAt("with".toUpperCase(), 1).matches("RSA%") and + type = KeyOpAlg::TAsymmetricCipher(KeyOpAlg::RSA()) + or + name.toUpperCase().splitAt("with".toUpperCase(), 1).matches("ECDSA%") and + type = KeyOpAlg::TSignature(KeyOpAlg::ECDSA()) + or + name.toUpperCase().splitAt("with".toUpperCase(), 1).matches("DSA%") and + type = KeyOpAlg::TSignature(KeyOpAlg::DSA()) + or + name.toUpperCase() = "RSASSA-PSS" and type = KeyOpAlg::TAsymmetricCipher(KeyOpAlg::RSA()) + or + name.toUpperCase().matches(["EDDSA", "ED25519", "ED448"]) and + type = KeyOpAlg::TSignature(KeyOpAlg::EDDSA()) + or + name.toUpperCase().matches("ML-DSA%") and type = KeyOpAlg::TSignature(KeyOpAlg::DSA()) + or + name.toUpperCase() = "HSS/LMS" and type = KeyOpAlg::TSignature(KeyOpAlg::HSS_LMS()) + } + + bindingset[name] + Crypto::HashType signature_name_to_hash_type_known(string name, int digestLength) { + result = hash_name_to_type_known(name.splitAt("with", 0), digestLength) } /** @@ -345,7 +392,7 @@ module JCAModel { override KeyOpAlg::AlgorithmType getAlgorithmType() { if cipher_name_to_type_known(_, super.getAlgorithmName()) then cipher_name_to_type_known(result, super.getAlgorithmName()) - else result instanceof KeyOpAlg::TUnknownKeyOperationAlgorithmType + else result instanceof KeyOpAlg::TOtherKeyOperationAlgorithmType } override int getKeySizeFixed() { @@ -999,7 +1046,8 @@ module JCAModel { override Crypto::AlgorithmInstance getAKnownAlgorithmSource() { result.(CipherStringLiteralAlgorithmInstance).getConsumer() = this or result.(KeyAgreementStringLiteralAlgorithmInstance).getConsumer() = this or - result.(EllipticCurveStringLiteralInstance).getConsumer() = this + result.(EllipticCurveStringLiteralInstance).getConsumer() = this or + result.(SignatureStringLiteralAlgorithmInstance).getConsumer() = this } KeyGeneratorGetInstanceCall getInstantiationCall() { result = instantiationCall } @@ -1047,6 +1095,21 @@ module JCAModel { } } + /** + * An instance of `java.security.SecureRandom.nextBytes(byte[])` call. + * This is already generally modeled for Java in CodeQL, but + * we model it again as part of the crypto API model to have a cohesive model. + */ + class JavaSecuritySecureRandom extends Crypto::RandomNumberGenerationInstance instanceof Call { + JavaSecuritySecureRandom() { + this.getCallee().hasQualifiedName("java.security", "SecureRandom", "nextBytes") + } + + override Crypto::DataFlowNode getOutputNode() { result.asExpr() = this.(Call).getArgument(0) } + + override string getGeneratorName() { result = this.(Call).getCallee().getName() } + } + class KeyGeneratorGenerateCall extends Crypto::KeyGenerationOperationInstance instanceof MethodCall { Crypto::KeyArtifactType type; @@ -1624,6 +1687,196 @@ module JCAModel { override Crypto::ConsumerInputDataFlowNode getNonceConsumer() { none() } } + /** + * Signatures + */ + module SignatureKnownAlgorithmToConsumerConfig implements DataFlow::ConfigSig { + predicate isSource(DataFlow::Node src) { src.asExpr() instanceof SignatureStringLiteral } + + predicate isSink(DataFlow::Node sink) { + sink = any(SignatureAlgorithmValueConsumer call).getInputNode() + } + } + + module SignatureKnownAlgorithmToConsumerFlow = + TaintTracking::Global; + + class SignatureGetInstanceCall extends MethodCall { + SignatureGetInstanceCall() { + this.getCallee().hasQualifiedName("java.security", "Signature", "getInstance") + } + + Expr getAlgorithmArg() { result = this.getArgument(0) } + } + + class SignatureGetInstanceAlgorithmValueConsumer extends SignatureAlgorithmValueConsumer instanceof Expr + { + SignatureGetInstanceAlgorithmValueConsumer() { + this = any(SignatureGetInstanceCall c).getAlgorithmArg() + } + + override Crypto::ConsumerInputDataFlowNode getInputNode() { result.asExpr() = this } + + override Crypto::AlgorithmInstance getAKnownAlgorithmSource() { + result.(SignatureStringLiteralAlgorithmInstance).getConsumer() = this + } + } + + class SignatureStringLiteral extends StringLiteral { + SignatureStringLiteral() { signature_names(this.getValue()) } + } + + class SignatureStringLiteralAlgorithmInstance extends Crypto::KeyOperationAlgorithmInstance instanceof SignatureStringLiteral + { + SignatureAlgorithmValueConsumer consumer; + + SignatureStringLiteralAlgorithmInstance() { + SignatureKnownAlgorithmToConsumerFlow::flow(DataFlow::exprNode(this), consumer.getInputNode()) + } + + SignatureAlgorithmValueConsumer getConsumer() { result = consumer } + + override string getRawAlgorithmName() { result = super.getValue() } + + override Crypto::KeyOpAlg::AlgorithmType getAlgorithmType() { + if signature_name_to_type_known(_, super.getValue()) + then signature_name_to_type_known(result, super.getValue()) + else result = Crypto::KeyOpAlg::TOtherKeyOperationAlgorithmType() + } + + override Crypto::ConsumerInputDataFlowNode getKeySizeConsumer() { + // TODO: trace to any key size initializer? + none() + } + + override int getKeySizeFixed() { + // TODO: are there known fixed key sizes to consider? + none() + } + + override Crypto::ModeOfOperationAlgorithmInstance getModeOfOperationAlgorithm() { none() } + + override Crypto::PaddingAlgorithmInstance getPaddingAlgorithm() { none() } + } + + class SignatureHashAlgorithmInstance extends Crypto::HashAlgorithmInstance instanceof SignatureStringLiteralAlgorithmInstance + { + Crypto::THashType hashType; + int digestLength; + + SignatureHashAlgorithmInstance() { + hashType = signature_name_to_hash_type_known(this.(StringLiteral).getValue(), digestLength) + } + + override string getRawHashAlgorithmName() { result = this.(StringLiteral).getValue() } + + override Crypto::THashType getHashFamily() { result = hashType } + + override int getFixedDigestLength() { result = digestLength } + } + + class SignatureInitCall extends MethodCall { + SignatureInitCall() { + this.getCallee().hasQualifiedName("java.security", "Signature", ["initSign", "initVerify"]) + } + + Expr getKeyArg() { + result = this.getArgument(0) + // TODO: verify can take in a certificate too? + } + } + + private class SignatureOperationCall extends MethodCall { + SignatureOperationCall() { + this.getMethod().hasQualifiedName("java.security", "Signature", ["update", "sign", "verify"]) + } + + predicate isIntermediate() { super.getMethod().getName() = "update" } + + Expr getMsgInput() { result = this.getArgument(0) and this.getMethod().getName() = "update" } + + Expr getSignatureOutput() { + // no args, the signature is returned + result = this and this.getMethod().getName() = "sign" and not exists(this.getArgument(0)) + or + // with args, the signature is written to the arg + result = this.getArgument(0) and this.getMethod().getName() = "sign" + } + + Expr getSignatureInput() { + result = this.getArgument(0) and this.getMethod().getName() = "verify" + } + + Crypto::KeyOperationSubtype getSubtype() { + result instanceof Crypto::TSignMode and this.getMethod().getName() = "sign" + or + result instanceof Crypto::TVerifyMode and this.getMethod().getName() = "verify" + } + } + + class SignatureOperationInstance extends Crypto::SignatureOperationInstance instanceof SignatureOperationCall + { + SignatureOperationInstance() { + // exclude update (only include sign and verify) + not super.isIntermediate() + } + + SignatureGetInstanceCall getInstantiationCall() { + result = SignatureFlowAnalysisImpl::getInstantiationFromUse(this, _, _) + } + + SignatureInitCall getInitCall() { + result = SignatureFlowAnalysisImpl::getInitFromUse(this, _, _) + } + + override Crypto::ConsumerInputDataFlowNode getInputConsumer() { + result.asExpr() = super.getMsgInput() or + result.asExpr() = + SignatureFlowAnalysisImpl::getAnIntermediateUseFromFinalUse(this, _, _).getMsgInput() + } + + override Crypto::ConsumerInputDataFlowNode getKeyConsumer() { + result.asExpr() = this.getInitCall().getKeyArg() + } + + override Crypto::AlgorithmValueConsumer getAnAlgorithmValueConsumer() { + result = this.getInstantiationCall().getAlgorithmArg() + } + + override Crypto::ArtifactOutputDataFlowNode getOutputArtifact() { + result.asExpr() = super.getSignatureOutput() or + result.asExpr() = + SignatureFlowAnalysisImpl::getAnIntermediateUseFromFinalUse(this, _, _).getSignatureOutput() + } + + override Crypto::AlgorithmValueConsumer getHashAlgorithmValueConsumer() { + // TODO: RSASSA-PSS literal sets hashes differently, through a ParameterSpec + result = this.getInstantiationCall().getAlgorithmArg() + } + + override predicate hasHashAlgorithmConsumer() { + // All jca signature algorithms specify a hash unless explicitly set as "NONEwith..." + exists(SignatureStringLiteralAlgorithmInstance i | + i.getConsumer() = this.getAnAlgorithmValueConsumer() and + not i.getRawAlgorithmName().toUpperCase().matches("NONEwith%".toUpperCase()) + ) + } + + override Crypto::KeyOperationSubtype getKeyOperationSubtype() { result = super.getSubtype() } + + override Crypto::ConsumerInputDataFlowNode getNonceConsumer() { none() } + + override Crypto::ConsumerInputDataFlowNode getSignatureConsumer() { + result.asExpr() = super.getSignatureInput() or + result.asExpr() = + SignatureFlowAnalysisImpl::getAnIntermediateUseFromFinalUse(this, _, _).getSignatureInput() + } + } + + module SignatureFlowAnalysisImpl = + GetInstanceInitUseFlowAnalysis; + /* * Elliptic Curves (EC) */ diff --git a/java/ql/test/experimental/library-tests/quantum/jca/AesWrapAndPBEWith.java b/java/ql/test/experimental/library-tests/quantum/jca/AesWrapAndPBEWith.java new file mode 100644 index 000000000000..775f02280b5c --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/AesWrapAndPBEWith.java @@ -0,0 +1,226 @@ +package com.example.crypto.algorithms; + +//import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import javax.crypto.SecretKeyFactory; +import javax.crypto.spec.IvParameterSpec; +import javax.crypto.spec.PBEKeySpec; +import javax.crypto.spec.SecretKeySpec; +import java.security.SecureRandom; +import java.util.Arrays; +import java.util.Base64; + +/** + * AesWrapAndPBEWithTest demonstrates key wrapping and password-based encryption + * using various transformations. + * + * This file includes: + * + * 1. AESWrap Examples: - secureAESWrap(): Uses a randomly generated wrapping + * key. - insecureAESWrap(): Uses a fixed, hard-coded wrapping key. + * + * 2. PBEWith Examples: - insecurePBEExample(): Uses the legacy + * PBEWithMD5AndDES. - securePBEExample(): Uses PBKDF2WithHmacSHA256. - + * additionalPBEExample(): Uses PBEWithSHA256And128BitAES-CBC-BC. - + * additionalPBEExample2(): Uses PBEWithSHA1And128BitAES-CBC-BC. + * + * 3. Dynamic PBE Encryption: - dynamicPBEEncryption(): Chooses the PBE + * transformation based on a configuration string. + * + * Best Practices: - Use secure random keys and salts. - Avoid legacy algorithms + * like PBEWithMD5AndDES. - Prefer modern KDFs (PBKDF2WithHmacSHA256) and secure + * provider-specific PBE transformations. + * + * SAST/CBOM Notes: - Insecure examples (PBEWithMD5AndDES, fixed keys) should be + * flagged. - Secure examples use random salt, high iteration counts, and strong + * algorithms. + */ +public class AesWrapAndPBEWith { + + // static { + // // Register BouncyCastle as a provider. + // Security.addProvider(new BouncyCastleProvider()); + // } + // =========================== + // 1. AESWrap Examples + // =========================== + /** + * Secure AES key wrapping. Generates a random 256-bit wrapping key to wrap + * a target AES key. + * + * @return The wrapped key (Base64-encoded). + * @throws Exception if an error occurs. + */ + public String secureAESWrap() throws Exception { + KeyGenerator kg = KeyGenerator.getInstance("AES"); + kg.init(256, new SecureRandom()); + SecretKey wrappingKey = kg.generateKey(); + + kg.init(128, new SecureRandom()); + SecretKey targetKey = kg.generateKey(); + + Cipher cipher = Cipher.getInstance("AESWrap"); + cipher.init(Cipher.WRAP_MODE, wrappingKey); + byte[] wrappedKey = cipher.wrap(targetKey); + + return Base64.getEncoder().encodeToString(wrappedKey); + } + + /** + * Insecure AES key wrapping. Uses a fixed (hard-coded) wrapping key. + * + * @return The wrapped key (Base64-encoded). + * @throws Exception if an error occurs. + */ + public String insecureAESWrap() throws Exception { + byte[] fixedKeyBytes = new byte[32]; + Arrays.fill(fixedKeyBytes, (byte) 0x01); + SecretKey wrappingKey = new SecretKeySpec(fixedKeyBytes, "AES"); + + KeyGenerator kg = KeyGenerator.getInstance("AES"); + kg.init(128, new SecureRandom()); + SecretKey targetKey = kg.generateKey(); + + Cipher cipher = Cipher.getInstance("AESWrap"); + cipher.init(Cipher.WRAP_MODE, wrappingKey); + byte[] wrappedKey = cipher.wrap(targetKey); + + return Base64.getEncoder().encodeToString(wrappedKey); + } + + // =========================== + // 2. PBEWith Examples + // =========================== + /** + * Insecure PBE example using PBEWithMD5AndDES. + * + * @param password The input password. + * @return The derived key (Base64-encoded). + * @throws Exception if key derivation fails. + */ + public String insecurePBEExample(String password) throws Exception { + byte[] salt = new byte[8]; + Arrays.fill(salt, (byte) 0x00); // Fixed salt (insecure) + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 1000, 64); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWithMD5AndDES"); + byte[] keyBytes = factory.generateSecret(spec).getEncoded(); + return Base64.getEncoder().encodeToString(keyBytes); + } + + /** + * Secure PBE example using PBKDF2WithHmacSHA256. + * + * @param password The input password. + * @return The derived 256-bit AES key (Base64-encoded). + * @throws Exception if key derivation fails. + */ + public String securePBEExample(String password) throws Exception { + byte[] salt = new byte[16]; + new SecureRandom().nextBytes(salt); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 10000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] keyBytes = factory.generateSecret(spec).getEncoded(); + SecretKey aesKey = new SecretKeySpec(keyBytes, "AES"); + return Base64.getEncoder().encodeToString(aesKey.getEncoded()); + } + + /** + * Additional PBE example using PBEWithSHA256And128BitAES-CBC-BC. + * + * @param password The input password. + * @param plaintext The plaintext to encrypt. + * @return The IV concatenated with ciphertext (Base64-encoded). + * @throws Exception if key derivation or encryption fails. + */ + public String additionalPBEExample(String password, String plaintext) throws Exception { + byte[] salt = new byte[16]; + new SecureRandom().nextBytes(salt); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 10000, 128); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWithSHA256And128BitAES-CBC-BC"); + SecretKey pbeKey = factory.generateSecret(spec); + SecretKey aesKey = new SecretKeySpec(pbeKey.getEncoded(), "AES"); + + Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); + byte[] iv = new byte[16]; + new SecureRandom().nextBytes(iv); + IvParameterSpec ivSpec = new IvParameterSpec(iv); + cipher.init(Cipher.ENCRYPT_MODE, aesKey, ivSpec); + byte[] ciphertext = cipher.doFinal(plaintext.getBytes()); + byte[] output = concatenate(iv, ciphertext); + return Base64.getEncoder().encodeToString(output); + } + + /** + * Additional PBE example using PBEWithSHA1And128BitAES-CBC-BC. This is less + * preferred than PBKDF2WithHmacSHA256 but demonstrates another variant. + * + * @param password The input password. + * @param plaintext The plaintext to encrypt. + * @return The IV concatenated with ciphertext (Base64-encoded). + * @throws Exception if key derivation or encryption fails. + */ + public String additionalPBEExample2(String password, String plaintext) throws Exception { + byte[] salt = new byte[16]; + new SecureRandom().nextBytes(salt); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 10000, 128); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBEWithSHA1And128BitAES-CBC-BC"); + SecretKey pbeKey = factory.generateSecret(spec); + SecretKey aesKey = new SecretKeySpec(pbeKey.getEncoded(), "AES"); + + Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); + byte[] iv = new byte[16]; + new SecureRandom().nextBytes(iv); + IvParameterSpec ivSpec = new IvParameterSpec(iv); + cipher.init(Cipher.ENCRYPT_MODE, aesKey, ivSpec); + byte[] ciphertext = cipher.doFinal(plaintext.getBytes()); + byte[] output = concatenate(iv, ciphertext); + return Base64.getEncoder().encodeToString(output); + } + + // =========================== + // 3. Dynamic PBE Encryption + // =========================== + /** + * Dynamically selects a PBE transformation based on a configuration string. + * + * Acceptable values: - "PBKDF2": Uses PBKDF2WithHmacSHA256. - "SHA256AES": + * Uses PBEWithSHA256And128BitAES-CBC-BC. - "SHA1AES": Uses + * PBEWithSHA1And128BitAES-CBC-BC. - Otherwise, falls back to insecure + * PBEWithMD5AndDES. + * + * @param config The configuration string. + * @param password The input password. + * @param plaintext The plaintext to encrypt. + * @return The Base64-encoded encrypted output. + * @throws Exception if an error occurs. + */ + public String dynamicPBEEncryption(String config, String password, String plaintext) throws Exception { + if ("PBKDF2".equalsIgnoreCase(config)) { + return securePBEExample(password); + } else if ("SHA256AES".equalsIgnoreCase(config)) { + return additionalPBEExample(password, plaintext); + } else if ("SHA1AES".equalsIgnoreCase(config)) { + return additionalPBEExample2(password, plaintext); + } else { + // Fallback insecure option. + return insecurePBEExample(password); + } + } + + // =========================== + // Helper Methods + // =========================== + /** + * Concatenates two byte arrays. + */ + private byte[] concatenate(byte[] a, byte[] b) { + byte[] result = new byte[a.length + b.length]; + System.arraycopy(a, 0, result, 0, a.length); + System.arraycopy(b, 0, result, a.length, b.length); + return result; + } + +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/AsymmetricEncryptionMacHybridCryptosystem.java b/java/ql/test/experimental/library-tests/quantum/jca/AsymmetricEncryptionMacHybridCryptosystem.java new file mode 100644 index 000000000000..8f844ba86207 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/AsymmetricEncryptionMacHybridCryptosystem.java @@ -0,0 +1,324 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +// import org.bouncycastle.pqc.jcajce.provider.BouncyCastlePQCProvider; +import java.security.*; +import java.security.spec.ECGenParameterSpec; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.KeyAgreement; +import javax.crypto.KeyGenerator; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * AsymmetricEncryptionMacHybridCryptosystem demonstrates hybrid cryptosystems + * that combine asymmetric encryption with a MAC. + * + * Flows: 1. RSA-OAEP + HMAC: - Secure Flow: Uses 2048-bit RSA-OAEP (with + * SHA256andMGF1Padding) to encapsulate a freshly generated AES key; then + * encrypts using AES-GCM with a random nonce and computes HMAC-SHA256 over the + * ciphertext. - Insecure Flow: Uses 1024-bit RSA (RSA/ECB/PKCS1Padding), + * AES-GCM with a fixed IV, and HMAC-SHA1. + * + * 2. ECIES + HMAC: - Secure Flow: Uses ephemeral ECDH key pairs (secp256r1); + * derives a shared secret and applies a simple KDF (SHA-256) to derive a + * 128-bit AES key; then uses AES-GCM with a random nonce and computes + * HMAC-SHA256. - Insecure Flow: Reuses a static EC key pair, directly truncates + * the shared secret without a proper KDF, uses a fixed IV, and computes + * HMAC-SHA1. + * + * 3. Dynamic Hybrid Selection: - Chooses between flows based on a configuration + * string. + * + * SAST/CBOM Notes: - Secure flows use proper ephemeral key generation, secure + * key sizes, KDF usage, and random nonces/IVs. - Insecure flows (static key + * reuse, fixed nonces, weak key sizes, raw shared secret truncation, and + * deprecated algorithms) should be flagged. + */ +public class AsymmetricEncryptionMacHybridCryptosystem { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // Security.addProvider(new BouncyCastlePQCProvider()); + // } + // ---------- Result Class ---------- + public static class HybridResult { + + private final byte[] encapsulatedKey; + private final byte[] ciphertext; + private final byte[] mac; + + public HybridResult(byte[] encapsulatedKey, byte[] ciphertext, byte[] mac) { + this.encapsulatedKey = encapsulatedKey; + this.ciphertext = ciphertext; + this.mac = mac; + } + + public byte[] getEncapsulatedKey() { + return encapsulatedKey; + } + + public byte[] getCiphertext() { + return ciphertext; + } + + public byte[] getMac() { + return mac; + } + + public String toBase64String() { + return "EncapsulatedKey: " + Base64.getEncoder().encodeToString(encapsulatedKey) + + "\nCiphertext: " + Base64.getEncoder().encodeToString(ciphertext) + + "\nMAC: " + Base64.getEncoder().encodeToString(mac); + } + } + + // ---------- Helper Methods ---------- + /** + * Generates an ephemeral ECDH key pair on secp256r1. + */ + public KeyPair generateECDHKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + kpg.initialize(new ECGenParameterSpec("secp256r1"), new SecureRandom()); + return kpg.generateKeyPair(); + } + + /** + * Generates an ephemeral X25519 key pair. + */ + public KeyPair generateX25519KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("X25519", "BC"); + kpg.initialize(255, new SecureRandom()); + return kpg.generateKeyPair(); + } + + /** + * Derives a shared secret using the provided key agreement algorithm. + * + * @param privateKey The private key. + * @param publicKey The corresponding public key. + * @param algorithm The key agreement algorithm (e.g., "ECDH" or "X25519"). + * @return The shared secret. + */ + public byte[] deriveSharedSecret(PrivateKey privateKey, PublicKey publicKey, String algorithm) throws Exception { + KeyAgreement ka = KeyAgreement.getInstance(algorithm, "BC"); + ka.init(privateKey); + ka.doPhase(publicKey, true); + return ka.generateSecret(); + } + + /** + * A simple KDF that hashes the input with SHA-256 and returns the first + * numBytes. + * + * @param input The input byte array. + * @param numBytes The desired number of output bytes. + * @return The derived key material. + */ + public byte[] simpleKDF(byte[] input, int numBytes) throws Exception { + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + byte[] hash = digest.digest(input); + return Arrays.copyOf(hash, numBytes); + } + + /** + * Concatenates two byte arrays. + */ + public byte[] concatenate(byte[] a, byte[] b) { + byte[] result = new byte[a.length + b.length]; + System.arraycopy(a, 0, result, 0, a.length); + System.arraycopy(b, 0, result, a.length, b.length); + return result; + } + + // ===================================================== + // 1. RSA-OAEP + HMAC Hybrid Cryptosystem + // ===================================================== + /** + * Generates a secure 2048-bit RSA key pair. + */ + public KeyPair generateRSAKeyPairGood() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); + kpg.initialize(2048); + return kpg.generateKeyPair(); + } + + /** + * Generates an insecure 1024-bit RSA key pair. + */ + public KeyPair generateRSAKeyPairBad() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); + kpg.initialize(1024); + return kpg.generateKeyPair(); + } + + /** + * Secure hybrid encryption using RSA-OAEP + HMAC-SHA256. + */ + public HybridResult secureRSAHybridEncryption(byte[] plaintext) throws Exception { + KeyPair rsaKP = generateRSAKeyPairGood(); + SecretKey aesKey = generateAESKey(); + + Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); + rsaCipher.init(Cipher.WRAP_MODE, rsaKP.getPublic()); + byte[] encapsulatedKey = rsaCipher.wrap(aesKey); + + byte[] iv = new byte[12]; + new SecureRandom().nextBytes(iv); + Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding"); + aesCipher.init(Cipher.ENCRYPT_MODE, aesKey, new GCMParameterSpec(128, iv)); + byte[] ciphertext = aesCipher.doFinal(plaintext); + byte[] fullCiphertext = concatenate(iv, ciphertext); + + byte[] macKey = generateAESKey().getEncoded(); + byte[] mac = secureHMACSHA256(new String(fullCiphertext), macKey); + + return new HybridResult(encapsulatedKey, fullCiphertext, mac); + } + + /** + * Insecure hybrid encryption using RSA/ECB/PKCS1Padding + HMAC-SHA1. + */ + public HybridResult insecureRSAHybridEncryption(byte[] plaintext) throws Exception { + KeyPair rsaKP = generateRSAKeyPairBad(); + SecretKey aesKey = generateAESKey(); + + Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding"); + rsaCipher.init(Cipher.WRAP_MODE, rsaKP.getPublic()); + byte[] encapsulatedKey = rsaCipher.wrap(aesKey); + + byte[] fixedIV = new byte[12]; // All zeros + Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding"); + aesCipher.init(Cipher.ENCRYPT_MODE, aesKey, new GCMParameterSpec(128, fixedIV)); + byte[] ciphertext = aesCipher.doFinal(plaintext); + byte[] fullCiphertext = concatenate(fixedIV, ciphertext); + + byte[] macKey = generateAESKey().getEncoded(); + byte[] mac = insecureHMACSHA1(new String(fullCiphertext), macKey); + + return new HybridResult(encapsulatedKey, fullCiphertext, mac); + } + + // ===================================================== + // 2. ECIES + HMAC Hybrid Cryptosystem + // ===================================================== + /** + * Secure hybrid encryption using ECIES (via ECDH) + HMAC-SHA256. + */ + public HybridResult secureECIESHybridEncryption(byte[] plaintext) throws Exception { + KeyPair aliceKP = generateECDHKeyPair(); + KeyPair bobKP = generateECDHKeyPair(); + byte[] sharedSecret = deriveSharedSecret(aliceKP.getPrivate(), bobKP.getPublic(), "ECDH"); + byte[] aesKeyBytes = simpleKDF(sharedSecret, 16); + SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES"); + + byte[] iv = new byte[12]; + new SecureRandom().nextBytes(iv); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, aesKey, new GCMParameterSpec(128, iv)); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] fullCiphertext = concatenate(iv, ciphertext); + + byte[] macKey = generateAESKey().getEncoded(); + byte[] mac = secureHMACSHA256(new String(fullCiphertext), macKey); + + byte[] ephemeralPubKey = aliceKP.getPublic().getEncoded(); + + return new HybridResult(ephemeralPubKey, fullCiphertext, mac); + } + + /** + * Insecure hybrid encryption using ECIES (via ECDH) + HMAC-SHA1. + */ + public HybridResult insecureECIESHybridEncryption(byte[] plaintext) throws Exception { + KeyPair staticKP = generateECDHKeyPair(); + byte[] sharedSecret = deriveSharedSecret(staticKP.getPrivate(), staticKP.getPublic(), "ECDH"); + byte[] aesKeyBytes = Arrays.copyOf(sharedSecret, 16); + SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES"); + + byte[] fixedIV = new byte[12]; // Fixed IV + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, aesKey, new GCMParameterSpec(128, fixedIV)); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] fullCiphertext = concatenate(fixedIV, ciphertext); + + byte[] macKey = generateAESKey().getEncoded(); + byte[] mac = insecureHMACSHA1(new String(fullCiphertext), macKey); + + byte[] staticPubKey = staticKP.getPublic().getEncoded(); + + return new HybridResult(staticPubKey, fullCiphertext, mac); + } + + // ===================================================== + // 3. Dynamic Hybrid Selection + // ===================================================== + /** + * Dynamically selects a hybrid encryption flow based on configuration. + * SAST: Dynamic selection introduces risk if insecure defaults are chosen. + * + * @param config The configuration string ("secureRSA", "insecureRSA", + * "secureECIES", "insecureECIES"). + * @param plaintext The plaintext to encrypt. + * @return A Base64-encoded string representation of the hybrid encryption + * result. + * @throws Exception if an error occurs. + */ + public String dynamicHybridEncryption(String config, byte[] plaintext) throws Exception { + HybridResult result; + if ("secureRSA".equalsIgnoreCase(config)) { + result = secureRSAHybridEncryption(plaintext); + } else if ("insecureRSA".equalsIgnoreCase(config)) { + result = insecureRSAHybridEncryption(plaintext); + } else if ("secureECIES".equalsIgnoreCase(config)) { + result = secureECIESHybridEncryption(plaintext); + } else if ("insecureECIES".equalsIgnoreCase(config)) { + result = insecureECIESHybridEncryption(plaintext); + } else { + // Fallback to insecure RSA hybrid encryption. + result = insecureRSAHybridEncryption(plaintext); + } + return result.toBase64String(); + } + + // ===================================================== + // 4. Helper Methods for HMAC and Symmetric Encryption + // ===================================================== + /** + * Secure HMAC using HMAC-SHA256. SAST: HMAC-SHA256 is secure. + */ + public byte[] secureHMACSHA256(String message, byte[] key) throws Exception { + Mac mac = Mac.getInstance("HmacSHA256", "BC"); + SecretKey secretKey = new SecretKeySpec(key, "HmacSHA256"); + mac.init(secretKey); + return mac.doFinal(message.getBytes()); + } + + /** + * Insecure HMAC using HMAC-SHA1. SAST: HMAC-SHA1 is deprecated and + * insecure. + */ + public byte[] insecureHMACSHA1(String message, byte[] key) throws Exception { + Mac mac = Mac.getInstance("HmacSHA1", "BC"); + SecretKey secretKey = new SecretKeySpec(key, "HmacSHA1"); + mac.init(secretKey); + return mac.doFinal(message.getBytes()); + } + + // ===================================================== + // 5. Helper Methods for Key/Nonce Generation + // ===================================================== + /** + * Generates a secure 256-bit AES key. SAST: Uses SecureRandom for key + * generation. + */ + public SecretKey generateAESKey() throws Exception { + KeyGenerator kg = KeyGenerator.getInstance("AES"); + kg.init(256, new SecureRandom()); + return kg.generateKey(); + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/ChainedEncryptionTest.java b/java/ql/test/experimental/library-tests/quantum/jca/ChainedEncryptionTest.java new file mode 100644 index 000000000000..2190921937e2 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/ChainedEncryptionTest.java @@ -0,0 +1,146 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; +import java.util.Arrays; +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.IvParameterSpec; + +public class ChainedEncryptionTest { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + // Encrypts using AES-GCM. Returns IV concatenated with ciphertext. + public static byte[] encryptAESGCM(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; // 12-byte nonce for AES-GCM + new SecureRandom().nextBytes(iv); + GCMParameterSpec spec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.ENCRYPT_MODE, key, spec); + byte[] ciphertext = cipher.doFinal(plaintext); + return concat(iv, ciphertext); + } + + // Decrypts AES-GCM ciphertext where IV is prepended. + public static byte[] decryptAESGCM(SecretKey key, byte[] ivCiphertext) throws Exception { + byte[] iv = Arrays.copyOfRange(ivCiphertext, 0, 12); + byte[] ciphertext = Arrays.copyOfRange(ivCiphertext, 12, ivCiphertext.length); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + GCMParameterSpec spec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.DECRYPT_MODE, key, spec); + return cipher.doFinal(ciphertext); + } + + // Encrypts using ChaCha20-Poly1305. Returns nonce concatenated with ciphertext. + public static byte[] encryptChaCha20Poly1305(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("ChaCha20-Poly1305", "BC"); + byte[] nonce = new byte[12]; // 12-byte nonce for ChaCha20-Poly1305 + new SecureRandom().nextBytes(nonce); + cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(nonce)); + byte[] ciphertext = cipher.doFinal(plaintext); + return concat(nonce, ciphertext); + } + + // Decrypts ChaCha20-Poly1305 ciphertext where nonce is prepended. + public static byte[] decryptChaCha20Poly1305(SecretKey key, byte[] nonceCiphertext) throws Exception { + byte[] nonce = Arrays.copyOfRange(nonceCiphertext, 0, 12); + byte[] ciphertext = Arrays.copyOfRange(nonceCiphertext, 12, nonceCiphertext.length); + Cipher cipher = Cipher.getInstance("ChaCha20-Poly1305", "BC"); + cipher.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(nonce)); + return cipher.doFinal(ciphertext); + } + + // Helper method to concatenate two byte arrays. + private static byte[] concat(byte[] a, byte[] b) { + byte[] result = new byte[a.length + b.length]; + System.arraycopy(a, 0, result, 0, a.length); + System.arraycopy(b, 0, result, a.length, b.length); + return result; + } + + /** + * Performs chained encryption and decryption in one function. First, + * plaintext is encrypted with AES-GCM (inner layer), then that ciphertext + * is encrypted with ChaCha20-Poly1305 (outer layer). The decryption process + * reverses these steps. + * + * @param plaintext The input plaintext. + * @return The decrypted plaintext as a String. + * @throws Exception if any cryptographic operation fails. + */ + public static String chainEncryptDecrypt(String plaintext) throws Exception { + byte[] plainBytes = plaintext.getBytes("UTF-8"); + + // Generate keys for inner and outer encryption. + KeyGenerator aesGen = KeyGenerator.getInstance("AES"); + aesGen.init(256, new SecureRandom()); + SecretKey innerKey = aesGen.generateKey(); + + KeyGenerator chachaGen = KeyGenerator.getInstance("ChaCha20", "BC"); + chachaGen.init(256, new SecureRandom()); + SecretKey outerKey = chachaGen.generateKey(); + + // Inner Encryption with AES-GCM. + byte[] aesIV = new byte[12]; // Random 12-byte IV. + new SecureRandom().nextBytes(aesIV); + Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding"); + GCMParameterSpec gcmSpec = new GCMParameterSpec(128, aesIV); + aesCipher.init(Cipher.ENCRYPT_MODE, innerKey, gcmSpec); + byte[] innerCiphertext = aesCipher.doFinal(plainBytes); + + // Outer Encryption with ChaCha20-Poly1305. + byte[] chachaNonce = new byte[12]; // Random 12-byte nonce. + new SecureRandom().nextBytes(chachaNonce); + Cipher chachaCipher = Cipher.getInstance("ChaCha20-Poly1305", "BC"); + chachaCipher.init(Cipher.ENCRYPT_MODE, outerKey, new IvParameterSpec(chachaNonce)); + byte[] outerCiphertext = chachaCipher.doFinal(innerCiphertext); + + // Outer Decryption. + Cipher chachaDec = Cipher.getInstance("ChaCha20-Poly1305", "BC"); + chachaDec.init(Cipher.DECRYPT_MODE, outerKey, new IvParameterSpec(chachaNonce)); + byte[] decryptedInnerCiphertext = chachaDec.doFinal(outerCiphertext); + + // Inner Decryption. + Cipher aesDec = Cipher.getInstance("AES/GCM/NoPadding"); + aesDec.init(Cipher.DECRYPT_MODE, innerKey, new GCMParameterSpec(128, aesIV)); + byte[] decryptedPlaintext = aesDec.doFinal(decryptedInnerCiphertext); + + return new String(decryptedPlaintext, "UTF-8"); + } + + public static void main(String[] args) throws Exception { + // Generate a 256-bit AES key for the first (inner) encryption. + KeyGenerator aesGen = KeyGenerator.getInstance("AES"); + aesGen.init(256, new SecureRandom()); + SecretKey aesKey = aesGen.generateKey(); + + // Generate a 256-bit key for ChaCha20-Poly1305 (outer encryption). + KeyGenerator chaChaGen = KeyGenerator.getInstance("ChaCha20"); + chaChaGen.init(256, new SecureRandom()); + SecretKey chaChaKey = chaChaGen.generateKey(); + + String originalText = "This is a secret message."; + byte[] plaintext = originalText.getBytes(); + + // Step 1: Encrypt plaintext with AES-GCM. + byte[] innerCiphertext = encryptAESGCM(aesKey, plaintext); + + // Step 2: Encrypt the AES-GCM ciphertext with ChaCha20-Poly1305. + byte[] outerCiphertext = encryptChaCha20Poly1305(chaChaKey, innerCiphertext); + + // Now, decrypt in reverse order. + // Step 3: Decrypt the outer layer (ChaCha20-Poly1305). + byte[] decryptedInnerCiphertext = decryptChaCha20Poly1305(chaChaKey, outerCiphertext); + + // Step 4: Decrypt the inner layer (AES-GCM). + byte[] decryptedPlaintext = decryptAESGCM(aesKey, decryptedInnerCiphertext); + + System.out.println("Original: " + originalText); + System.out.println("Decrypted: " + new String(decryptedPlaintext)); + } + +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/Digest.java b/java/ql/test/experimental/library-tests/quantum/jca/Digest.java new file mode 100644 index 000000000000..412bf578ac18 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/Digest.java @@ -0,0 +1,256 @@ +package com.example.crypto.artifacts; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; + +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.security.SecureRandom; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.SecretKeyFactory; +import javax.crypto.spec.PBEKeySpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * DigestTestCase demonstrates the further use of cryptographic digests + * as inputs to more complex cryptosystems. In real-world applications, + * digest outputs are often used as keys, key material for key derivation, + * or as identifiers. This file shows several flows: + * + * 1. Basic digest generation using SHA-256 (secure) and MD5/SHA-1 (insecure). + * 2. Unsalted versus salted digest for password input. + * 3. PBKDF2 for secure key derivation. + * 4. Using a digest as direct key material for AES encryption (processDigest). + * 5. Using a digest as an identifier (alternativeDigestFlow). + * 6. **Further Use**: Deriving two separate keys (one for encryption and one + * for MAC) + * from a digest via PBKDF2 and using them in an authenticated encryption flow. + * + * SAST/CBOM notes: + * - Secure algorithms (e.g. SHA-256, HMAC-SHA256, PBKDF2WithHmacSHA256) are + * acceptable. + * - Insecure functions (e.g. MD5, SHA-1) and unsalted password digests are + * flagged. + * - Using a raw digest directly as key material is ambiguous unless produced by + * a proper KDF. + */ +public class Digest { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + + // ---------- Digest Generation Flows ---------- + + /** + * Secure digest generation using SHA-256. + * SAST: SHA-256 is secure. + */ + public void simpleHashing() throws Exception { + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + byte[] hash = digest.digest("Simple Test Data".getBytes()); + processDigest(hash); + } + + /** + * Insecure digest generation using MD5. + * SAST: MD5 is deprecated and insecure. + */ + public void insecureMD5Hashing() throws Exception { + MessageDigest md5Digest = MessageDigest.getInstance("MD5"); + byte[] hash = md5Digest.digest("Weak Hash Example".getBytes()); + processDigest(hash); + } + + /** + * Insecure unsalted password hashing using SHA-256. + * SAST: Unsalted password hashing is vulnerable to rainbow table attacks. + */ + public void insecureUnsaltedPasswordHashing(String password) throws Exception { + MessageDigest sha256Digest = MessageDigest.getInstance("SHA-256"); + byte[] hash = sha256Digest.digest(password.getBytes()); + processDigest(hash); + } + + /** + * Secure salted hashing using SHA-256. + * SAST: Salting the input improves security. + */ + public void secureSaltedHashing(String password) throws Exception { + byte[] salt = generateSalt(16); + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + digest.update(salt); + byte[] hash = digest.digest(password.getBytes()); + processDigest(hash); + } + + /** + * Secure key derivation using PBKDF2 with HMAC-SHA256. + * SAST: PBKDF2 with sufficient iterations is recommended. + */ + public void securePBKDF2Hashing(String password) throws Exception { + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 10000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] hash = factory.generateSecret(spec).getEncoded(); + processDigest(hash); + } + + /** + * Insecure digest generation using SHA-1. + * SAST: SHA-1 is deprecated due to collision vulnerabilities. + */ + public void insecureRawSHA1Hashing(String input) throws Exception { + MessageDigest sha1Digest = MessageDigest.getInstance("SHA-1"); + byte[] hash = sha1Digest.digest(input.getBytes()); + processDigest(hash); + } + + /** + * Secure MAC computation using HMAC-SHA256. + * SAST: HMAC-SHA256 is considered secure. + */ + public void secureHMACHashing(String input, byte[] key) throws Exception { + Mac hmac = Mac.getInstance("HmacSHA256"); + SecretKey secretKey = new SecretKeySpec(key, "HmacSHA256"); + hmac.init(secretKey); + byte[] hash = hmac.doFinal(input.getBytes()); + processDigest(hash); + } + + // ---------- Further Use of Digest Outputs ---------- + + /** + * Processes the digest by using it directly as key material for AES encryption. + * SAST: Using a raw digest as key material is acceptable only if the digest is + * produced + * via a secure KDF. This method is ambiguous if the digest is from an insecure + * function. + * + * @param digest The computed digest. + * @throws Exception if encryption fails. + */ + public void processDigest(byte[] digest) throws Exception { + // Derive a 128-bit AES key from the digest. + SecretKey key = new SecretKeySpec(digest, 0, 16, "AES"); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, key, new SecureRandom()); + byte[] encryptedData = cipher.doFinal("Sensitive Data".getBytes()); + storeEncryptedDigest(encryptedData); + } + + /** + * Alternative flow: Uses the digest as an identifier (e.g., checksum) and + * encrypts it. + * SAST: Using a digest as an identifier is common; encryption must use secure + * primitives. + * + * @param digest The computed digest. + * @throws Exception if encryption fails. + */ + public void alternativeDigestFlow(byte[] digest) throws Exception { + byte[] identifier = Base64.getEncoder().encode(digest); + encryptAndSend(identifier); + } + + /** + * Further use: Derives two separate keys from a digest using PBKDF2, + * then uses one key for encryption and the other for computing a MAC over the + * ciphertext. + * + * SAST: This approach of key derivation and splitting is acceptable if PBKDF2 + * is used securely. + * + * @param digest The input digest (must be generated from a secure source). + * @throws Exception if key derivation or encryption fails. + */ + public void furtherUseDigestForKeyDerivation(byte[] digest) throws Exception { + // Treat the digest (in Base64) as a password input to PBKDF2. + String digestAsPassword = Base64.getEncoder().encodeToString(digest); + byte[] salt = generateSalt(16); + // Derive 256 bits (32 bytes) of key material. + PBEKeySpec spec = new PBEKeySpec(digestAsPassword.toCharArray(), salt, 10000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] keyMaterial = factory.generateSecret(spec).getEncoded(); + // Split into two 128-bit keys. + byte[] encryptionKeyBytes = Arrays.copyOfRange(keyMaterial, 0, 16); + byte[] macKeyBytes = Arrays.copyOfRange(keyMaterial, 16, 32); + SecretKey encryptionKey = new SecretKeySpec(encryptionKeyBytes, "AES"); + SecretKey macKey = new SecretKeySpec(macKeyBytes, "HmacSHA256"); + + // Encrypt sample data using the derived encryption key. + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, encryptionKey, new SecureRandom()); + byte[] ciphertext = cipher.doFinal("Further Use Test Data".getBytes()); + + // Compute HMAC over the ciphertext using the derived MAC key. + Mac mac = Mac.getInstance("HmacSHA256"); + mac.init(macKey); + byte[] computedMac = mac.doFinal(ciphertext); + + // In production, these outputs would be securely stored or transmitted. + byte[] output = new byte[ciphertext.length + computedMac.length]; + System.arraycopy(ciphertext, 0, output, 0, ciphertext.length); + System.arraycopy(computedMac, 0, output, ciphertext.length, computedMac.length); + storeEncryptedDigest(output); + } + + /** + * Encrypts data using AES-GCM and simulates secure transmission or storage. + * SAST: Uses a securely generated AES key. + * + * @param data The data to encrypt. + * @throws Exception if encryption fails. + */ + public void encryptAndSend(byte[] data) throws Exception { + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + SecretKey key = generateAESKey(); + cipher.init(Cipher.ENCRYPT_MODE, key, new SecureRandom()); + byte[] encryptedData = cipher.doFinal(data); + storeEncryptedDigest(encryptedData); + } + + /** + * Simulates secure storage or transmission of an encrypted digest. + * SAST: In production, this method would implement secure storage/transmission. + * + * @param encryptedDigest The encrypted digest. + */ + public void storeEncryptedDigest(byte[] encryptedDigest) { + // For static analysis purposes, this method represents a secure output + // mechanism. + String stored = Base64.getEncoder().encodeToString(encryptedDigest); + } + + // ---------- Helper Methods ---------- + + /** + * Generates a secure 256-bit AES key. + * SAST: Key generation uses a strong RNG. + * + * @return A SecretKey for AES. + * @throws NoSuchAlgorithmException if AES is unsupported. + */ + private SecretKey generateAESKey() throws NoSuchAlgorithmException { + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); + return keyGen.generateKey(); + } + + /** + * Generates a random salt of the specified length using SecureRandom. + * SAST: Salting is essential for secure digest computations. + * + * @param length The salt length. + * @return A byte array representing the salt. + */ + private byte[] generateSalt(int length) { + byte[] salt = new byte[length]; + new SecureRandom().nextBytes(salt); + return salt; + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/EllipticCurve1.java b/java/ql/test/experimental/library-tests/quantum/jca/EllipticCurve1.java new file mode 100644 index 000000000000..71481b7e7a92 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/EllipticCurve1.java @@ -0,0 +1,155 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; + +import java.security.KeyPair; +import java.security.KeyPairGenerator; +import java.util.Base64; + +/** + * EllipticCurve1 demonstrates generating EC key pairs for various curve + * categories. + * + * Curve categories covered: + * - NIST: e.g., secp256r1, secp384r1, secp521r1. + * - SEC: e.g., secp256k1 (from the Standards for Efficient Cryptography, SEC2). + * - BRAINPOOL: e.g., brainpoolP256r1. + * - CURVE25519: for key agreement (X25519) or signatures (Ed25519). + * - CURVE448: for key agreement (X448). + * - C2: Binary curves; for example, sect163r2 (if available). + * - SM2: Chinese SM2 curve, often named sm2p256v1. + * - ES: Elliptic curve signature based on EdDSA, here using Ed25519. + * - OtherEllipticCurveType: A fallback (using secp256r1). + * + * Best practices: + * - Use ephemeral key generation with a strong RNG. + * - Select curves from secure families (e.g., NIST, Brainpool, Curve25519/448, + * SM2). + * - Use a crypto provider (e.g., BouncyCastle) that supports the desired + * curves. + * + * In a production environment, the curve type may be externally configured. + */ +public class EllipticCurve1 { + + // static { + // // Register the BouncyCastle provider to access a wide range of curves. + // Security.addProvider(new BouncyCastleProvider()); + // } + + /** + * Generates a key pair using a NIST curve (e.g., secp256r1). + */ + public KeyPair generateNISTKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + // secp256r1 is widely used (also known as P-256) + kpg.initialize(new java.security.spec.ECGenParameterSpec("secp256r1")); + return kpg.generateKeyPair(); + } + + /** + * Generates a key pair using a SEC curve (e.g., secp256k1). + */ + public KeyPair generateSECCurveKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + // secp256k1 is commonly used in Bitcoin and other blockchain applications. + kpg.initialize(new java.security.spec.ECGenParameterSpec("secp256k1")); + return kpg.generateKeyPair(); + } + + /** + * Generates a key pair using a Brainpool curve (e.g., brainpoolP256r1). + */ + public KeyPair generateBrainpoolKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + // "brainpoolP256r1" is a commonly recommended Brainpool curve. + kpg.initialize(new java.security.spec.ECGenParameterSpec("brainpoolP256r1")); + return kpg.generateKeyPair(); + } + + /** + * Generates an X25519 key pair (for key agreement). + */ + public KeyPair generateCurve25519KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("X25519", "BC"); + // No further parameters are needed for X25519. + return kpg.generateKeyPair(); + } + + /** + * Generates an X448 key pair (for key agreement). + */ + public KeyPair generateCurve448KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("X448", "BC"); + return kpg.generateKeyPair(); + } + + /** + * Generates a key pair for a binary (C2) curve. + * Example: sect163r2 is a binary field curve. + */ + public KeyPair generateC2CurveKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + // "sect163r2" is one of the binary field curves supported by BouncyCastle. + kpg.initialize(new java.security.spec.ECGenParameterSpec("sect163r2")); + return kpg.generateKeyPair(); + } + + /** + * Generates a key pair for the SM2 curve. + * SM2 is a Chinese cryptographic standard. + */ + public KeyPair generateSM2KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + // "sm2p256v1" is the standard SM2 curve. + kpg.initialize(new java.security.spec.ECGenParameterSpec("sm2p256v1")); + return kpg.generateKeyPair(); + } + + /** + * Generates a key pair for ES (Elliptic curve signature using EdDSA). + * This example uses Ed25519. + */ + public KeyPair generateESKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("Ed25519", "BC"); + return kpg.generateKeyPair(); + } + + /** + * Generates a key pair for an "Other" elliptic curve type. + * This serves as a fallback example (using secp256r1). + */ + public KeyPair generateOtherEllipticCurveKeyPair() throws Exception { + return generateNISTKeyPair(); // Fallback to secp256r1 + } + + /** + * Main method demonstrating key pair generation for various curve types. + */ + public static void main(String[] args) { + try { + EllipticCurve1 examples = new EllipticCurve1(); + System.out.println("NIST (secp256r1): " + + Base64.getEncoder().encodeToString(examples.generateNISTKeyPair().getPublic().getEncoded())); + System.out.println("SEC (secp256k1): " + + Base64.getEncoder().encodeToString(examples.generateSECCurveKeyPair().getPublic().getEncoded())); + System.out.println("Brainpool (brainpoolP256r1): " + + Base64.getEncoder().encodeToString(examples.generateBrainpoolKeyPair().getPublic().getEncoded())); + System.out.println("Curve25519 (X25519): " + + Base64.getEncoder().encodeToString(examples.generateCurve25519KeyPair().getPublic().getEncoded())); + System.out.println("Curve448 (X448): " + + Base64.getEncoder().encodeToString(examples.generateCurve448KeyPair().getPublic().getEncoded())); + System.out.println("C2 (sect163r2): " + + Base64.getEncoder().encodeToString(examples.generateC2CurveKeyPair().getPublic().getEncoded())); + System.out.println("SM2 (sm2p256v1): " + + Base64.getEncoder().encodeToString(examples.generateSM2KeyPair().getPublic().getEncoded())); + System.out.println("ES (Ed25519): " + + Base64.getEncoder().encodeToString(examples.generateESKeyPair().getPublic().getEncoded())); + System.out.println("Other (Fallback, secp256r1): " + + Base64.getEncoder() + .encodeToString(examples.generateOtherEllipticCurveKeyPair().getPublic().getEncoded())); + } catch (Exception e) { + e.printStackTrace(); + } + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/EllipticCurve2.java b/java/ql/test/experimental/library-tests/quantum/jca/EllipticCurve2.java new file mode 100644 index 000000000000..41def510f18a --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/EllipticCurve2.java @@ -0,0 +1,272 @@ +package com.example.crypto.algorithms; + +//import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; +import java.security.spec.ECGenParameterSpec; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.KeyAgreement; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * EllipticCurve2 demonstrates real-world uses of elliptic curve algorithms, + * including key pair generation, key agreement (ECDH), digital signatures + * (ECDSA, EdDSA), and a simple simulation of ECIES (using ECDH + AES-GCM). + * + * Curve types shown include: - NIST (e.g., secp256r1) - SEC (e.g., secp256k1) - + * Brainpool (e.g., brainpoolP256r1) - CURVE25519 (for X25519 key agreement) - + * ES (e.g., Ed25519 for signatures) - Other fallback (e.g., secp256r1 for + * "OtherEllipticCurveType") + * + * Best practices: - Use ephemeral keys and a strong RNG. - Use proper key + * agreement (with a KDF if needed) and digital signature schemes. - Avoid + * static key reuse or using weak curves. + * + * SAST/CBOM considerations: - Secure implementations use ephemeral keys and + * modern curves. - Insecure practices (e.g., static keys or reusing keys) must + * be flagged. + */ +public class EllipticCurve2 { + + // static { + // // Register BouncyCastle provider for additional curves and algorithms. + // Security.addProvider(new BouncyCastleProvider()); + // } + // ---------------------------- + // 1. Key Pair Generation Examples + // ---------------------------- + /** + * Generates a key pair using a NIST curve (secp256r1). + */ + public KeyPair generateNISTKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + kpg.initialize(new ECGenParameterSpec("secp256r1"), new SecureRandom()); + return kpg.generateKeyPair(); + } + + /** + * Generates a key pair using a SEC curve (secp256k1). + */ + public KeyPair generateSECCurveKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + kpg.initialize(new ECGenParameterSpec("secp256k1"), new SecureRandom()); + return kpg.generateKeyPair(); + } + + /** + * Generates a key pair using a Brainpool curve (brainpoolP256r1). + */ + public KeyPair generateBrainpoolKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + kpg.initialize(new ECGenParameterSpec("brainpoolP256r1"), new SecureRandom()); + return kpg.generateKeyPair(); + } + + /** + * Generates an X25519 key pair. + */ + public KeyPair generateX25519KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("X25519", "BC"); + return kpg.generateKeyPair(); + } + + /** + * Generates an Ed25519 key pair (used for signatures). + */ + public KeyPair generateEd25519KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("Ed25519", "BC"); + return kpg.generateKeyPair(); + } + + /** + * Generates a key pair for "OtherEllipticCurveType" as a fallback (using + * secp256r1). + */ + public KeyPair generateOtherEllipticCurveKeyPair() throws Exception { + return generateNISTKeyPair(); + } + + // ---------------------------- + // 2. Key Agreement (ECDH) Examples + // ---------------------------- + /** + * Performs ECDH key agreement using two ephemeral NIST key pairs. Secure + * Example: Uses ephemeral keys and a strong RNG. + * + * @return The shared secret. + */ + public byte[] performECDHKeyAgreement() throws Exception { + KeyPair aliceKP = generateNISTKeyPair(); + KeyPair bobKP = generateNISTKeyPair(); + + KeyAgreement ka = KeyAgreement.getInstance("ECDH", "BC"); + ka.init(aliceKP.getPrivate()); + ka.doPhase(bobKP.getPublic(), true); + return ka.generateSecret(); + } + + /** + * Insecure ECDH Example: Uses a static key pair for both parties. SAST: + * Reusing the same key pair eliminates forward secrecy and is insecure. + * + * @return The (insecure) shared secret. + */ + public byte[] insecureECDHKeyAgreement() throws Exception { + KeyPair staticKP = generateNISTKeyPair(); + KeyAgreement ka = KeyAgreement.getInstance("ECDH", "BC"); + ka.init(staticKP.getPrivate()); + ka.doPhase(staticKP.getPublic(), true); + return ka.generateSecret(); + } + + // ---------------------------- + // 3. Digital Signature Examples + // ---------------------------- + /** + * Generates an ECDSA signature using a NIST key pair. Secure Example. + * + * @param message The message to sign. + * @return The signature. + */ + public byte[] generateECDSASignature(byte[] message) throws Exception { + KeyPair kp = generateNISTKeyPair(); + Signature signature = Signature.getInstance("SHA256withECDSA", "BC"); + signature.initSign(kp.getPrivate()); + signature.update(message); + return signature.sign(); + } + + /** + * Verifies an ECDSA signature using the corresponding NIST key pair. + * + * @param message The original message. + * @param signatureBytes The signature to verify. + * @param kp The key pair used for signing. + * @return True if the signature is valid. + */ + public boolean verifyECDSASignature(byte[] message, byte[] signatureBytes, KeyPair kp) throws Exception { + Signature signature = Signature.getInstance("SHA256withECDSA", "BC"); + signature.initVerify(kp.getPublic()); + signature.update(message); + return signature.verify(signatureBytes); + } + + /** + * Generates an Ed25519 signature. Secure Example: Ed25519 is a modern, + * high-performance signature scheme. + * + * @param message The message to sign. + * @return The signature. + */ + public byte[] generateEd25519Signature(byte[] message) throws Exception { + KeyPair kp = generateEd25519KeyPair(); + Signature signature = Signature.getInstance("Ed25519", "BC"); + signature.initSign(kp.getPrivate()); + signature.update(message); + return signature.sign(); + } + + /** + * Verifies an Ed25519 signature. + * + * @param message The original message. + * @param signatureBytes The signature to verify. + * @param kp The key pair used for signing. + * @return True if the signature is valid. + */ + public boolean verifyEd25519Signature(byte[] message, byte[] signatureBytes, KeyPair kp) throws Exception { + Signature signature = Signature.getInstance("Ed25519", "BC"); + signature.initVerify(kp.getPublic()); + signature.update(message); + return signature.verify(signatureBytes); + } + + // ---------------------------- + // 4. ECIES-like Encryption (ECDH + AES-GCM) + // ---------------------------- + /** + * A simple simulation of ECIES using ECDH for key agreement and AES-GCM for + * encryption. Secure Example: Uses ephemeral ECDH key pairs, a KDF to + * derive a symmetric key, and AES-GCM with a random nonce. + * + * @param plaintext The plaintext to encrypt. + * @return The concatenation of the ephemeral public key, IV, and ciphertext + * (Base64-encoded). + * @throws Exception if encryption fails. + */ + public String eciesEncryptionExample(byte[] plaintext) throws Exception { + // Generate ephemeral key pairs for two parties. + KeyPair senderKP = generateNISTKeyPair(); + KeyPair receiverKP = generateNISTKeyPair(); + + // Perform ECDH key agreement. + KeyAgreement ka = KeyAgreement.getInstance("ECDH", "BC"); + ka.init(senderKP.getPrivate()); + ka.doPhase(receiverKP.getPublic(), true); + byte[] sharedSecret = ka.generateSecret(); + + // Derive a symmetric key from the shared secret using SHA-256 (first 16 bytes + // for AES-128). + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + byte[] derivedKey = digest.digest(sharedSecret); + derivedKey = Arrays.copyOf(derivedKey, 16); + SecretKey aesKey = new SecretKeySpec(derivedKey, "AES"); + + // Encrypt plaintext using AES-GCM with a random nonce. + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; + new SecureRandom().nextBytes(iv); + GCMParameterSpec spec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.ENCRYPT_MODE, aesKey, spec); + byte[] ciphertext = cipher.doFinal(plaintext); + + // For ECIES, include the sender's ephemeral public key with the output. + byte[] senderPub = senderKP.getPublic().getEncoded(); + byte[] output = concatenate(senderPub, concatenate(iv, ciphertext)); + + return Base64.getEncoder().encodeToString(output); + } + + // ---------------------------- + // 5. Main Method for Demonstration + // ---------------------------- + public static void main(String[] args) { + try { + EllipticCurve2 test = new EllipticCurve2(); + + // Key Agreement Example: + byte[] sharedSecret = test.performECDHKeyAgreement(); + System.out.println("ECDH Shared Secret (Base64): " + Base64.getEncoder().encodeToString(sharedSecret)); + + // ECDSA Signature Example: + byte[] message = "Test message for ECDSA".getBytes(); + KeyPair nistKP = test.generateNISTKeyPair(); + byte[] ecdsaSig = test.generateECDSASignature(message); + boolean validSig = test.verifyECDSASignature(message, ecdsaSig, nistKP); + System.out.println("ECDSA Signature valid? " + validSig); + + // Ed25519 Signature Example: + byte[] edSig = test.generateEd25519Signature(message); + KeyPair edKP = test.generateEd25519KeyPair(); + boolean validEdSig = test.verifyEd25519Signature(message, edSig, edKP); + System.out.println("Ed25519 Signature valid? " + validEdSig); + + // ECIES-like Encryption Example: + String eciesOutput = test.eciesEncryptionExample("Secret ECIES Message".getBytes()); + System.out.println("ECIES-like Encrypted Output (Base64): " + eciesOutput); + + } catch (Exception e) { + e.printStackTrace(); + } + } + + private byte[] concatenate(byte[] a, byte[] b) { + byte[] result = new byte[a.length + b.length]; + System.arraycopy(a, 0, result, 0, a.length); + System.arraycopy(b, 0, result, a.length, b.length); + return result; + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/Encryption1.java b/java/ql/test/experimental/library-tests/quantum/jca/Encryption1.java new file mode 100644 index 000000000000..74b2070d13ec --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/Encryption1.java @@ -0,0 +1,182 @@ +package com.example.crypto.algorithms; + +//import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; + +/** + * This class demonstrates several encryption schemes along with SAST/CBOM + * classification notes. + * + * Methods include: + * + * 1. simpleAESEncryption: Uses AES in GCM mode. + * - CBOM: AES-GCM is classified as secure (Parent: AEAD). + * - SAST: Secure symmetric encryption pattern; safe when used properly. + * + * 2. insecureAESWithECB: Uses AES in ECB mode. + * - CBOM: AES-ECB is classified as insecure (Parent: SymmetricEncryption). + * - SAST: Insecure encryption pattern; flagged as vulnerable due to lack of IV + * and predictable structure. + * + * 3. rsaOaepEncryption / rsaOaepDecryption: Use RSA with OAEP padding. + * - CBOM: RSA-OAEP is classified as secure for public-key encryption (Parent: + * Hybrid Cryptosystem). + * - SAST: Secure for small payloads/key encapsulation; must only encrypt small + * data blocks. + * + * 4. rsaKemEncryption: Demonstrates a key encapsulation mechanism (KEM) using + * RSA-OAEP. + * - CBOM: RSA-KEM is recognized as secure (Parent: RSA-OAEP based KEM). + * - SAST: Secure when used to encapsulate symmetric keys in a hybrid system. + * + * 5. hybridEncryption: Combines RSA-OAEP for key encapsulation with AES-GCM for + * data encryption. + * - CBOM: Hybrid encryption (Parent: RSA-OAEP + AES-GCM) is classified as + * secure. + * - SAST: Secure hybrid encryption pattern; recommended for large data + * encryption. + */ +public class Encryption1 { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + + /** + * Simple AES-GCM encryption. + * + * SAST/CBOM Notes: + * - Algorithm: AES/GCM/NoPadding with a 256-bit key. + * - Parent Classification: AEAD (Authenticated Encryption with Associated + * Data). + * - SAST: Considered safe when properly implemented (uses IV and tag). + */ + public void simpleAESEncryption() throws Exception { + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); // 256-bit AES key. + SecretKey key = keyGen.generateKey(); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; // 12-byte IV recommended for GCM. + new SecureRandom().nextBytes(iv); + GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv); // 128-bit authentication tag. + cipher.init(Cipher.ENCRYPT_MODE, key, gcmSpec); + byte[] encryptedData = cipher.doFinal("Sensitive Data".getBytes()); + System.out.println("AES-GCM Encrypted Data: " + Base64.getEncoder().encodeToString(encryptedData)); + } + + /** + * Insecure AES encryption using ECB mode. + * + * SAST/CBOM Notes: + * - Algorithm: AES/ECB/NoPadding with a 256-bit key. + * - Parent Classification: SymmetricEncryption (ECB mode is inherently + * insecure). + * - SAST: Flagged as vulnerable; ECB mode does not use an IV and reveals data + * patterns. + */ + public void insecureAESWithECB() throws Exception { + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); // 256-bit AES key. + SecretKey key = keyGen.generateKey(); + // AES/ECB mode is insecure due to the deterministic nature of the block cipher + // without an IV. + Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, key); + byte[] encryptedData = cipher.doFinal("Sensitive Data".getBytes()); + System.out.println("AES-ECB Encrypted Data (Insecure): " + Base64.getEncoder().encodeToString(encryptedData)); + } + + /** + * RSA encryption using OAEP with SHA-256 and MGF1 padding. + * + * SAST/CBOM Notes: + * - Algorithm: RSA/ECB/OAEPWithSHA-256AndMGF1Padding. + * - Parent Classification: Hybrid Cryptosystem. RSA-OAEP is commonly used in + * hybrid schemes. + * - SAST: Secure for encrypting small payloads or for key encapsulation; + * caution when encrypting large data. + */ + public void rsaOaepEncryption(PublicKey publicKey, String data) throws Exception { + Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); + cipher.init(Cipher.ENCRYPT_MODE, publicKey); + byte[] encryptedData = cipher.doFinal(data.getBytes()); + System.out.println("RSA-OAEP Encrypted Data: " + Base64.getEncoder().encodeToString(encryptedData)); + } + + /** + * RSA decryption using OAEP with SHA-256 and MGF1 padding. + * + * SAST/CBOM Notes: + * - Algorithm: RSA/ECB/OAEPWithSHA-256AndMGF1Padding. + * - Parent Classification: Hybrid Cryptosystem. + * - SAST: Secure when used with the correct corresponding private key. + */ + public void rsaOaepDecryption(PrivateKey privateKey, byte[] encryptedData) throws Exception { + Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); + cipher.init(Cipher.DECRYPT_MODE, privateKey); + byte[] decryptedData = cipher.doFinal(encryptedData); + System.out.println("Decrypted RSA-OAEP Data: " + new String(decryptedData)); + } + + /** + * RSA-KEM encryption: encapsulates an AES key using RSA-OAEP. + * + * SAST/CBOM Notes: + * - Algorithm: RSA-OAEP used as a Key Encapsulation Mechanism (KEM) for an AES + * key. + * - Parent Classification: RSA-OAEP based KEM. + * - SAST: Recognized as a secure key encapsulation pattern; used as part of + * hybrid encryption schemes. + */ + public void rsaKemEncryption(PublicKey rsaPublicKey) throws Exception { + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); // 256-bit AES key. + SecretKey aesKey = keyGen.generateKey(); + + Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); + rsaCipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey); + byte[] encryptedAesKey = rsaCipher.doFinal(aesKey.getEncoded()); + + System.out.println("RSA-KEM Encrypted AES Key: " + Base64.getEncoder().encodeToString(encryptedAesKey)); + } + + /** + * Hybrid encryption: combines RSA-OAEP for key encapsulation with AES-GCM for + * data encryption. + * + * SAST/CBOM Notes: + * - Algorithms: RSA-OAEP (for encrypting the AES key) and AES-GCM (for + * encrypting the data). + * - Parent Classification: Hybrid Cryptosystem (RSA-OAEP + AES-GCM). + * - SAST: This pattern is considered secure when implemented correctly; + * recommended for large data encryption. + */ + public void hybridEncryption(PublicKey rsaPublicKey, String data) throws Exception { + // Generate a 256-bit AES key for symmetric encryption. + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); + SecretKey aesKey = keyGen.generateKey(); + + // Encrypt the AES key using RSA-OAEP. + Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); + rsaCipher.init(Cipher.ENCRYPT_MODE, rsaPublicKey); + byte[] encryptedAesKey = rsaCipher.doFinal(aesKey.getEncoded()); + + // Encrypt the actual data using AES-GCM. + Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; // 12-byte IV recommended for GCM. + new SecureRandom().nextBytes(iv); + GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv); + aesCipher.init(Cipher.ENCRYPT_MODE, aesKey, gcmSpec); + byte[] encryptedData = aesCipher.doFinal(data.getBytes()); + + System.out.println( + "Hybrid Encryption - Encrypted AES Key: " + Base64.getEncoder().encodeToString(encryptedAesKey)); + System.out.println("Hybrid Encryption - Encrypted Data: " + Base64.getEncoder().encodeToString(encryptedData)); + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/Encryption2.java b/java/ql/test/experimental/library-tests/quantum/jca/Encryption2.java new file mode 100644 index 000000000000..edcfa0302045 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/Encryption2.java @@ -0,0 +1,179 @@ +package com.example.crypto.algorithms; + +//import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; +import java.security.spec.ECGenParameterSpec; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.KeyAgreement; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * This class demonstrates encryption schemes using elliptic-curve + * Diffie-Hellman (ECDH) and hybrid encryption methods, including a post-quantum + * hybrid scheme. + * + * SAST/CBOM Classification: + * + * 1. EC Key Generation & ECDH Key Agreement: - Parent Classification: + * Asymmetric Key Generation / Key Agreement. - SAST: Secure when using + * established curves (secp256r1) and reputable providers (BouncyCastle). + * + * 2. ECDH Hybrid Encryption: - Parent Classification: Hybrid Cryptosystem (ECDH + * + AEAD). - SAST: Uses ECDH for key agreement and AES/GCM for encryption. + * However, the derivation of an AES key by applying a single SHA-256 hash to + * the shared secret may be flagged as a weak key derivation method. A dedicated + * KDF (e.g., HKDF) is recommended. + * + * 3. Post-Quantum Hybrid Encryption: - Parent Classification: Hybrid + * Cryptosystem (Classical ECDH + Post-Quantum Secret + KDF + AEAD). - SAST: + * Combining classical and post-quantum components is advanced and secure if + * implemented properly. The custom HKDF expand function provided here is + * simplistic and may be flagged in a CBOM analysis; a standard HKDF library + * should be used in production. + */ +public class Encryption2 { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + /** + * Generates an Elliptic Curve (EC) key pair using the secp256r1 curve. + * + * SAST/CBOM Notes: - Algorithm: EC key pair generation. - Parent + * Classification: Asymmetric Key Generation. - SAST: Considered secure when + * using strong randomness and a reputable provider. + * + * @return an EC KeyPair. + */ + public KeyPair generateECKeyPair() throws Exception { + KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC", "BC"); + keyPairGenerator.initialize(new ECGenParameterSpec("secp256r1"), new SecureRandom()); + return keyPairGenerator.generateKeyPair(); + } + + /** + * Derives a shared secret using Elliptic Curve Diffie-Hellman (ECDH). + * + * SAST/CBOM Notes: - Algorithm: ECDH key agreement. - Parent + * Classification: Asymmetric Key Agreement. - SAST: Secure when both + * parties use strong EC keys and proper randomness. + * + * @param privateKey the private key of one party. + * @param publicKey the public key of the other party. + * @return the derived shared secret as a byte array. + */ + public byte[] deriveSharedSecret(PrivateKey privateKey, PublicKey publicKey) throws Exception { + KeyAgreement keyAgreement = KeyAgreement.getInstance("ECDH", "BC"); + keyAgreement.init(privateKey); + keyAgreement.doPhase(publicKey, true); + return keyAgreement.generateSecret(); + } + + /** + * Performs hybrid encryption using ECDH to derive a shared secret, then + * derives an AES key by hashing the shared secret with SHA-256, and finally + * encrypts the data with AES-GCM. + * + * SAST/CBOM Notes: - Parent Classification: Hybrid Cryptosystem (ECDH + + * AES-GCM). - SAST: While ECDH and AES-GCM are secure, the key derivation + * method here (a single SHA-256 hash) is not as robust as using a dedicated + * KDF. This approach may be flagged and is recommended for improvement. + * + * @param recipientPublicKey the recipient's public EC key. + * @param data the plaintext data to encrypt. + */ + public void ecdhHybridEncryption(PublicKey recipientPublicKey, String data) throws Exception { + // Generate an ephemeral EC key pair for the sender. + KeyPair senderKeyPair = generateECKeyPair(); + // Derive the shared secret using ECDH. + byte[] sharedSecret = deriveSharedSecret(senderKeyPair.getPrivate(), recipientPublicKey); + + // Derive an AES key by hashing the shared secret with SHA-256. + // SAST Note: Using a direct hash for key derivation is simplistic and may be + // flagged. + MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); + byte[] aesKeyBytes = sha256.digest(sharedSecret); + // Use the first 16 bytes (128 bits) as the AES key. + SecretKey aesKey = new SecretKeySpec(aesKeyBytes, 0, 16, "AES"); + + // Encrypt the data using AES-GCM. + Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; // 12-byte IV recommended for GCM. + new SecureRandom().nextBytes(iv); + GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv); // 128-bit authentication tag. + aesCipher.init(Cipher.ENCRYPT_MODE, aesKey, gcmSpec); + byte[] encryptedData = aesCipher.doFinal(data.getBytes()); + + System.out.println( + "ECDH Hybrid Encryption - Encrypted Data: " + Base64.getEncoder().encodeToString(encryptedData)); + } + + /** + * Performs post-quantum hybrid encryption by combining a classical + * ECDH-derived secret with a post-quantum shared secret. The two secrets + * are combined using a custom HKDF expansion, and the derived key is used + * to encrypt data with AES-GCM. + * + * SAST/CBOM Notes: - Parent Classification: Hybrid Cryptosystem (Classical + * ECDH + Post-Quantum Secret + KDF + AES-GCM). - SAST: The combination of + * classical and post-quantum secrets is a modern approach. However, the + * custom HKDF expand function is simplistic and may be flagged as insecure. + * Use a standard HKDF implementation in production. + * + * @param ecPublicKey the recipient's EC public key. + * @param pqSharedSecret the post-quantum shared secret from a separate + * algorithm. + */ + public void postQuantumHybridEncryption(PublicKey ecPublicKey, byte[] pqSharedSecret) throws Exception { + // Step 1: Perform classical ECDH key agreement to derive a shared secret. + byte[] ecdhSharedSecret = deriveSharedSecret(generateECKeyPair().getPrivate(), ecPublicKey); + + // Step 2: Combine the ECDH secret and the post-quantum secret using a + // simplified HKDF expansion. + // SAST Note: This custom HKDF implementation is minimal and does not follow the + // full HKDF spec. + byte[] combinedSecret = hkdfExpand(ecdhSharedSecret, pqSharedSecret, 32); + // Use the first 16 bytes as the AES key (128-bit key). + SecretKey aesKey = new SecretKeySpec(combinedSecret, 0, 16, "AES"); + + // Step 3: Encrypt the data using AES-GCM. + Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; // 12-byte IV recommended for GCM. + new SecureRandom().nextBytes(iv); + GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv); + aesCipher.init(Cipher.ENCRYPT_MODE, aesKey, gcmSpec); + byte[] encryptedData = aesCipher.doFinal("Post-Quantum Hybrid Encryption Data".getBytes()); + + System.out.println("Post-Quantum Hybrid Encryption - Encrypted Data: " + + Base64.getEncoder().encodeToString(encryptedData)); + } + + /** + * A simplified HKDF expansion function that uses HMAC-SHA256 to derive a + * key of a desired length. + * + * SAST/CBOM Notes: - Parent Classification: Key Derivation Function (KDF). + * - SAST: Custom KDF implementations are risky if not thoroughly vetted. + * This simple HKDF expand function lacks the full HKDF mechanism (e.g., + * multiple iterations, info, and context parameters) and may be flagged. It + * is recommended to use a standardized HKDF library. + * + * @param inputKey the input key material. + * @param salt a salt value (here, the post-quantum shared secret is used as + * the salt). + * @param length the desired length of the derived key. + * @return a derived key of the specified length. + */ + private byte[] hkdfExpand(byte[] inputKey, byte[] salt, int length) throws Exception { + Mac hmac = Mac.getInstance("HmacSHA256"); + SecretKey secretKey = new SecretKeySpec(salt, "HmacSHA256"); + hmac.init(secretKey); + byte[] extractedKey = hmac.doFinal(inputKey); + return Arrays.copyOf(extractedKey, length); + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/Hash.java b/java/ql/test/experimental/library-tests/quantum/jca/Hash.java new file mode 100644 index 000000000000..d4e6985eac67 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/Hash.java @@ -0,0 +1,313 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.crypto.digests.SHA3Digest; +// import org.bouncycastle.crypto.digests.Blake2bDigest; +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.io.FileInputStream; +import java.io.IOException; +import java.security.*; +import java.util.Base64; +import java.util.Properties; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.SecretKeyFactory; +import javax.crypto.spec.SecretKeySpec; +import javax.crypto.spec.PBEKeySpec; + +/** + * This class demonstrates various hashing, HMAC, and password hashing + * techniques. + * + * SAST/CBOM Classification Notes: + * + * 1. simpleSHA256Hash: - Parent Classification: Cryptographic Hash Function. - + * SAST: Uses SHA-256, which is widely regarded as secure. + * + * 2. insecureMD5Hash: - Parent Classification: Cryptographic Hash Function. - + * SAST: MD5 is cryptographically broken and should be flagged as insecure. + * + * 3. hashWithBouncyCastleSHA3: - Parent Classification: Cryptographic Hash + * Function (SHA3). - SAST: Uses SHA3-256 from BouncyCastle; considered secure. + * + * 4. hashWithBouncyCastleBlake2b: - Parent Classification: Cryptographic Hash + * Function (BLAKE2). - SAST: Uses BLAKE2b-512; considered secure if used + * correctly. + * + * 5. hashAndSign & verifyHashSignature: - Parent Classification: Digital + * Signature (RSA-based). - SAST: Uses SHA256withRSA for signing and + * verification; secure if key management is proper. + * + * 6. hashForDataIntegrityCheck: - Parent Classification: Data Integrity Check. + * - SAST: Uses SHA-256 to verify integrity; considered secure. + * + * 7. hashWithVariousAlgorithms: - Parent Classification: Cryptographic Hash + * Function. - SAST: Iterates through multiple algorithms; insecure algorithms + * (MD5, SHA-1) may be flagged. + * + * 8. hmacWithVariousAlgorithms: - Parent Classification: Message Authentication + * Code (MAC). - SAST: Iterates through various HMAC algorithms; HmacSHA1 is + * considered weaker than SHA256 and above. + * + * 9. hashForPasswordStorage: - Parent Classification: Password-Based Key + * Derivation Function (PBKDF). - SAST: Uses PBKDF2WithHmacSHA256 with salt and + * iteration count; considered secure, though iteration counts should be + * reviewed against current standards. + * + * 10. hashFromUnknownConfig: - Parent Classification: Dynamic Cryptographic + * Hash Function. - SAST: Loading the hash algorithm from an external + * configuration introduces risk of misconfiguration. + * + * 11. insecureHashBasedRNG: - Parent Classification: Pseudo-Random Number + * Generator (PRNG) using hash. - SAST: Uses a fixed seed with various hash + * algorithms; flagged as insecure due to predictability. + */ +public class Hash { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + /** + * Computes a SHA-256 hash of static test data. + * + * CBOM/SAST Classification: - Uses SHA-256: Classified as secure. + */ + public void simpleSHA256Hash() throws Exception { + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + byte[] hash = digest.digest("Simple Test Data".getBytes()); + System.out.println("SHA-256 Hash: " + Base64.getEncoder().encodeToString(hash)); + } + + /** + * Computes an MD5 hash of static data. + * + * CBOM/SAST Classification: - Uses MD5: Classified as insecure. - SAST: MD5 + * is deprecated for cryptographic purposes due to collision + * vulnerabilities. + */ + public void insecureMD5Hash() throws Exception { + MessageDigest md5Digest = MessageDigest.getInstance("MD5"); + byte[] hash = md5Digest.digest("Weak Hash Example".getBytes()); + System.out.println("MD5 Hash (Insecure): " + Base64.getEncoder().encodeToString(hash)); + } + + // /** + // * Computes a SHA3-256 hash using BouncyCastle's SHA3Digest. + // * + // * CBOM/SAST Classification: + // * - Uses SHA3-256: Classified as secure. + // * - SAST: BouncyCastle's implementation is considered reliable. + // */ + // public void hashWithBouncyCastleSHA3(String input) { + // SHA3Digest digest = new SHA3Digest(256); + // byte[] inputBytes = input.getBytes(); + // digest.update(inputBytes, 0, inputBytes.length); + // byte[] hash = new byte[digest.getDigestSize()]; + // digest.doFinal(hash, 0); + // System.out.println("SHA3-256 (BC) Hash: " + Base64.getEncoder().encodeToString(hash)); + // } + // /** + // * Computes a BLAKE2b-512 hash using BouncyCastle's Blake2bDigest. + // * + // * CBOM/SAST Classification: + // * - Uses BLAKE2b-512: Classified as secure. + // * - SAST: BLAKE2b is modern and fast, considered secure when used correctly. + // */ + // public void hashWithBouncyCastleBlake2b(String input) { + // Blake2bDigest digest = new Blake2bDigest(512); + // byte[] inputBytes = input.getBytes(); + // digest.update(inputBytes, 0, inputBytes.length); + // byte[] hash = new byte[digest.getDigestSize()]; + // digest.doFinal(hash, 0); + // System.out.println("BLAKE2b-512 (BC) Hash: " + Base64.getEncoder().encodeToString(hash)); + // } + /** + * Signs the hash of the input using SHA256withRSA. + * + * CBOM/SAST Classification: - Digital Signature (RSA): Classified as secure + * if keys are managed correctly. - SAST: The combination of SHA256 and RSA + * is a standard and secure pattern. + * + * @param input The input data to be signed. + * @param privateKey The RSA private key used for signing. + */ + public void hashAndSign(String input, PrivateKey privateKey) throws Exception { + Signature signature = Signature.getInstance("SHA256withRSA"); + signature.initSign(privateKey); + signature.update(input.getBytes()); + byte[] signedData = signature.sign(); + System.out.println("Signed Hash: " + Base64.getEncoder().encodeToString(signedData)); + } + + /** + * Verifies the signature of the input data. + * + * CBOM/SAST Classification: - Digital Signature Verification: Classified as + * secure when using SHA256withRSA. - SAST: Should correctly verify that the + * signed hash matches the input. + * + * @param input The original input data. + * @param signedHash The signed hash to verify. + * @param publicKey The RSA public key corresponding to the private key that + * signed the data. + * @return true if the signature is valid, false otherwise. + */ + public boolean verifyHashSignature(String input, byte[] signedHash, PublicKey publicKey) throws Exception { + Signature signature = Signature.getInstance("SHA256withRSA"); + signature.initVerify(publicKey); + signature.update(input.getBytes()); + return signature.verify(signedHash); + } + + /** + * Computes a SHA-256 hash for data integrity checking and compares it with + * an expected hash. + * + * CBOM/SAST Classification: - Data Integrity: Uses SHA-256 for integrity + * checks, which is secure. - SAST: A correct implementation for verifying + * data has not been tampered with. + * + * @param data The input data. + * @param expectedHash The expected Base64-encoded hash. + */ + public void hashForDataIntegrityCheck(String data, String expectedHash) throws Exception { + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + byte[] hash = digest.digest(data.getBytes()); + String computedHash = Base64.getEncoder().encodeToString(hash); + System.out.println("Computed Hash: " + computedHash); + System.out.println("Validation: " + (computedHash.equals(expectedHash) ? "Pass" : "Fail")); + } + + /** + * Computes hashes of the input data using various algorithms. + * + * CBOM/SAST Classification: - Cryptographic Hash Functions: Iterates + * through multiple hash functions. - SAST: While many are secure (e.g., + * SHA-256, SHA-512, SHA3), MD5 and SHA-1 are insecure and should be flagged + * if used in security-critical contexts. + * + * @param input The input data to hash. + */ + public void hashWithVariousAlgorithms(String input) throws Exception { + String[] algorithms = {"SHA-1", "SHA-224", "SHA-256", "SHA-384", "SHA-512", "SHA3-256", "SHA3-512", + "BLAKE2B-512", "BLAKE2S-256", "MD5"}; + for (String algorithm : algorithms) { + MessageDigest digest = MessageDigest.getInstance(algorithm); + byte[] hash = digest.digest(input.getBytes()); + System.out.println(algorithm + " Hash: " + Base64.getEncoder().encodeToString(hash)); + } + } + + /** + * Computes HMACs of the input data using various algorithms. + * + * CBOM/SAST Classification: - Message Authentication Code (MAC): Iterates + * through different HMAC algorithms. - SAST: HmacSHA256, HmacSHA384, + * HmacSHA512, HmacSHA3-256, and HmacSHA3-512 are secure; HmacSHA1 is + * considered less secure and may be flagged. + * + * @param input The input data. + * @param key The secret key used for HMAC computation. + */ + public void hmacWithVariousAlgorithms(String input, byte[] key) throws Exception { + String[] algorithms = {"HmacSHA1", "HmacSHA256", "HmacSHA384", "HmacSHA512", "HmacSHA3-256", "HmacSHA3-512"}; + for (String algorithm : algorithms) { + Mac mac = Mac.getInstance(algorithm); + SecretKey secretKey = new SecretKeySpec(key, algorithm); + mac.init(secretKey); + byte[] hmac = mac.doFinal(input.getBytes()); + System.out.println(algorithm + " HMAC: " + Base64.getEncoder().encodeToString(hmac)); + } + } + + /** + * Computes a PBKDF2 hash for password storage. + * + * CBOM/SAST Classification: - Password-Based Key Derivation Function + * (PBKDF): Uses PBKDF2WithHmacSHA256. - SAST: Considered secure when using + * a strong salt and an appropriate iteration count. Note: The iteration + * count (10000) should be reviewed against current security standards. + * + * @param password The password to hash. + */ + public void hashForPasswordStorage(String password) throws Exception { + byte[] salt = generateSecureSalt(16); + // 10,000 iterations and a 256-bit derived key. + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 10000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] hash = factory.generateSecret(spec).getEncoded(); + System.out.println("PBKDF2 Hash: " + Base64.getEncoder().encodeToString(hash)); + } + + /** + * Dynamically loads a hash algorithm from configuration and computes a + * hash. + * + * CBOM/SAST Classification: - Dynamic Cryptographic Hash Selection: + * Algorithm is loaded from a config file. - SAST: May be flagged as risky + * because an insecure or unintended algorithm might be chosen. + */ + public void hashFromUnknownConfig() throws Exception { + String algorithm = loadHashAlgorithmFromConfig("config.properties"); + MessageDigest digest = MessageDigest.getInstance(algorithm); + byte[] hash = digest.digest("Config-based Hashing".getBytes()); + System.out.println("Dynamically Loaded Hash Algorithm (" + algorithm + "): " + + Base64.getEncoder().encodeToString(hash)); + } + + /** + * Demonstrates an insecure method for generating pseudo-random bytes by + * using a fixed seed with hash algorithms. + * + * CBOM/SAST Classification: - Insecure RNG: Uses a fixed seed with various + * hash algorithms. - SAST: This approach is insecure because it produces + * predictable output and should be flagged. + */ + public void insecureHashBasedRNG() throws Exception { + String[] algorithms = {"SHA-256", "SHA-512", "SHA3-256", "SHA3-512"}; + for (String algorithm : algorithms) { + MessageDigest digest = MessageDigest.getInstance(algorithm); + byte[] seed = "fixed-seed".getBytes(); // Fixed seed: insecure and predictable. + digest.update(seed); + byte[] pseudoRandomBytes = digest.digest(); + System.out.println("Insecure RNG using " + algorithm + ": " + + Base64.getEncoder().encodeToString(pseudoRandomBytes)); + } + } + + /** + * Loads the hash algorithm from an external configuration file. + * + * CBOM/SAST Classification: - Dynamic Configuration: External config + * loading. - SAST: The use of external configuration may introduce risks if + * the config file is compromised. + * + * @param configPath Path to the configuration file. + * @return The hash algorithm to be used (default is SHA-256). + */ + private String loadHashAlgorithmFromConfig(String configPath) { + Properties properties = new Properties(); + try (FileInputStream fis = new FileInputStream(configPath)) { + properties.load(fis); + } catch (IOException e) { + e.printStackTrace(); + } + return properties.getProperty("hash.algorithm", "SHA-256"); + } + + /** + * Generates a secure salt using a cryptographically strong random number + * generator. + * + * CBOM/SAST Classification: - Secure Salt Generation: Uses SecureRandom. - + * SAST: This is a best-practice approach for generating salts for password + * hashing. + * + * @param length The desired salt length. + * @return A byte array representing the salt. + */ + private byte[] generateSecureSalt(int length) { + byte[] salt = new byte[length]; + new SecureRandom().nextBytes(salt); + return salt; + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/IVArtifact.java b/java/ql/test/experimental/library-tests/quantum/jca/IVArtifact.java new file mode 100644 index 000000000000..dfd94d82358d --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/IVArtifact.java @@ -0,0 +1,285 @@ +package com.example.crypto.artifacts; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import javax.crypto.spec.IvParameterSpec; +import javax.crypto.spec.GCMParameterSpec; +import java.security.*; +import java.util.Base64; +import java.util.random.*; +import java.util.Properties; +import java.util.Random; +import java.io.FileInputStream; +import java.io.IOException; +import java.util.Arrays; + +public class IVArtifact { + + // static { + // Security.addProvider(new BouncyCastleProvider()); // Ensure BouncyCastle is available + // } + /** + * Simple Case: Generates a secure IV and encrypts with + * AES/CBC/PKCS5Padding. + */ + public void simpleIVEncryption() throws Exception { + SecretKey key = generateAESKey(); + IvParameterSpec ivSpec = new IvParameterSpec(secureIV(16)); + Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); + cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec); + byte[] ciphertext = cipher.doFinal("Simple Test Data".getBytes()); + } + + public void encryptWithIV(byte[] plaintext, SecretKey key, IvParameterSpec ivSpec, String cipherAlgorithm) + throws Exception { + Cipher cipher = Cipher.getInstance(cipherAlgorithm); + cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec); + byte[] ciphertext = cipher.doFinal(plaintext); + } + + public void complexIVFlow() { + IvParameterSpec ivSpec = new IvParameterSpec(useSecureMethod() ? secureIV(16) : insecureIV(16)); + processIV(ivSpec); + + // Example dynamic cipher selection with IV usage + String cipherAlgorithm = loadCipherAlgorithm(); + try { + encryptWithIV("Sensitive Data".getBytes(), generateAESKey(), ivSpec, cipherAlgorithm); + } catch (Exception e) { + e.printStackTrace(); + } + } + + private boolean useSecureMethod() { + return System.currentTimeMillis() % 2 == 0; + } + + private void processIV(IvParameterSpec ivSpec) { + String ivBase64 = Base64.getEncoder().encodeToString(ivSpec.getIV()); + } + + private String loadCipherAlgorithm() { + Properties properties = new Properties(); + try { + properties.load(new FileInputStream("crypto-config.properties")); + } catch (IOException e) { + e.printStackTrace(); + } + return properties.getProperty("cipher.algorithm", "AES/CBC/PKCS5Padding"); + } + + private SecretKey generateAESKey() throws NoSuchAlgorithmException { + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); + return keyGen.generateKey(); + } + + private byte[] secureIV(int length) { + byte[] iv = new byte[length]; + new SecureRandom().nextBytes(iv); + return iv; + } + + private byte[] insecureIV(int length) { + byte[] iv = new byte[length]; + new Random().nextBytes(iv); + return iv; + } + + // ------------------------------- + // 1. Direct Fixed IV Usage + // ------------------------------- + /** + * Encrypts plaintext using AES-GCM with a fixed IV (all zeros). This is an + * insecure practice as IV reuse in AES-GCM undermines confidentiality and + * integrity. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] encryptWithFixedIV(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] fixedIV = new byte[12]; // 12-byte fixed IV (all zeros) + GCMParameterSpec spec = new GCMParameterSpec(128, fixedIV); + cipher.init(Cipher.ENCRYPT_MODE, key, spec); + return cipher.doFinal(plaintext); + } + + // ------------------------------- + // 2. Cached IV Usage + // ------------------------------- + // Cache an IV for reuse in multiple encryptions (insecure) + private byte[] cachedIV = null; + + /** + * Encrypts plaintext using AES-GCM with an IV cached from the first call. + * Reusing the same IV across multiple encryptions is insecure. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] encryptWithCachedIV(SecretKey key, byte[] plaintext) throws Exception { + if (cachedIV == null) { + cachedIV = new byte[12]; + new SecureRandom().nextBytes(cachedIV); + } + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + GCMParameterSpec spec = new GCMParameterSpec(128, cachedIV); + cipher.init(Cipher.ENCRYPT_MODE, key, spec); + return cipher.doFinal(plaintext); + } + + // ------------------------------- + // 3. Indirect IV Reuse via Deterministic Derivation + // ------------------------------- + /** + * Encrypts plaintext using AES-GCM with an IV derived deterministically + * from a constant. This method computes a SHA-256 hash of a constant string + * and uses the first 12 bytes as the IV. Such derived IVs are fixed and + * must not be reused. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] encryptWithDerivedIV(SecretKey key, byte[] plaintext) throws Exception { + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + byte[] constantHash = digest.digest("fixedConstant".getBytes("UTF-8")); + byte[] derivedIV = Arrays.copyOf(constantHash, 12); // Deterministically derived IV + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + GCMParameterSpec spec = new GCMParameterSpec(128, derivedIV); + cipher.init(Cipher.ENCRYPT_MODE, key, spec); + return cipher.doFinal(plaintext); + } + + // ------------------------------- + // 4. Reusing a Single IV Across Multiple Messages + // ------------------------------- + /** + * Encrypts an array of plaintext messages using AES-GCM with the same IV + * for every message. Reusing an IV across messages is insecure in + * authenticated encryption schemes. + * + * @param key The AES key. + * @param plaintexts An array of plaintext messages. + * @return An array of ciphertexts. + * @throws Exception if encryption fails. + */ + public byte[][] encryptMultipleMessagesWithSameIV(SecretKey key, byte[][] plaintexts) throws Exception { + byte[] iv = new byte[12]; + new SecureRandom().nextBytes(iv); // Generate once and reuse + byte[][] ciphertexts = new byte[plaintexts.length][]; + for (int i = 0; i < plaintexts.length; i++) { + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + GCMParameterSpec spec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.ENCRYPT_MODE, key, spec); + ciphertexts[i] = cipher.doFinal(plaintexts[i]); + } + return ciphertexts; + } + + /** + * Encrypts the given plaintext using AES-GCM with the provided key and IV. + * + * @param key The AES key. + * @param ivSpec The IV specification. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext (IV is not prepended here for clarity). + * @throws Exception if encryption fails. + */ + public byte[] encrypt(SecretKey key, IvParameterSpec ivSpec, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + // Use 128-bit authentication tag length. + GCMParameterSpec spec = new GCMParameterSpec(128, ivSpec.getIV()); + cipher.init(Cipher.ENCRYPT_MODE, key, spec); + return cipher.doFinal(plaintext); + } + + /** + * Example 1: Reuses the same IvParameterSpec object across two encryption + * calls. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return An array containing two ciphertexts generated with the same + * IvParameterSpec. + * @throws Exception if encryption fails. + */ + public byte[][] encryptUsingSameIvParameterSpec(SecretKey key, byte[] plaintext) throws Exception { + // Fixed IV (all zeros for demonstration purposes; insecure in production) + byte[] fixedIV = new byte[12]; + IvParameterSpec fixedIvSpec = new IvParameterSpec(fixedIV); + // Encrypt the plaintext twice using the same IvParameterSpec. + byte[] ciphertext1 = encrypt(key, fixedIvSpec, plaintext); + byte[] ciphertext2 = encrypt(key, fixedIvSpec, plaintext); + return new byte[][]{ciphertext1, ciphertext2}; + } + + /** + * Example 2: Creates two different IvParameterSpec objects that share the + * same underlying IV array. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return An array containing two ciphertexts generated with two + * IvParameterSpec objects constructed from the same IV array. + * @throws Exception if encryption fails. + */ + public byte[][] encryptUsingDifferentIvSpecSameIVArray(SecretKey key, byte[] plaintext) throws Exception { + // Create a fixed IV array (all zeros for demonstration; insecure in production) + byte[] fixedIV = new byte[12]; + // Create two distinct IvParameterSpec objects from the same IV array reference. + IvParameterSpec ivSpec1 = new IvParameterSpec(fixedIV); + IvParameterSpec ivSpec2 = new IvParameterSpec(fixedIV); + // Encrypt the plaintext twice. + byte[] ciphertext1 = encrypt(key, ivSpec1, plaintext); + byte[] ciphertext2 = encrypt(key, ivSpec2, plaintext); + return new byte[][]{ciphertext1, ciphertext2}; + } + + // ------------------------------- + // Main Method for Demonstration + // ------------------------------- + public static void main(String[] args) { + try { + IVArtifact test = new IVArtifact(); + KeyGenerator kg = KeyGenerator.getInstance("AES"); + kg.init(256, new SecureRandom()); + SecretKey key = kg.generateKey(); + byte[] plaintext = "Sensitive Data".getBytes(); + + // Example 1: Fixed IV usage + byte[] fixedIVCipher1 = test.encryptWithFixedIV(key, plaintext); + byte[] fixedIVCipher2 = test.encryptWithFixedIV(key, plaintext); + System.out.println("Fixed IV Encryption 1: " + Base64.getEncoder().encodeToString(fixedIVCipher1)); + System.out.println("Fixed IV Encryption 2: " + Base64.getEncoder().encodeToString(fixedIVCipher2)); + + // Example 2: Cached IV usage + byte[] cachedIVCipher1 = test.encryptWithCachedIV(key, plaintext); + byte[] cachedIVCipher2 = test.encryptWithCachedIV(key, plaintext); + System.out.println("Cached IV Encryption 1: " + Base64.getEncoder().encodeToString(cachedIVCipher1)); + System.out.println("Cached IV Encryption 2: " + Base64.getEncoder().encodeToString(cachedIVCipher2)); + + // Example 3: Indirect IV (derived) + byte[] derivedIVCipher = test.encryptWithDerivedIV(key, plaintext); + System.out.println("Derived IV Encryption: " + Base64.getEncoder().encodeToString(derivedIVCipher)); + + // Example 4: Reusing the same IV across multiple messages + byte[][] messages = {"Message One".getBytes(), "Message Two".getBytes(), "Message Three".getBytes()}; + byte[][] multiCiphers = test.encryptMultipleMessagesWithSameIV(key, messages); + for (int i = 0; i < multiCiphers.length; i++) { + System.out.println("Multi-message Encryption " + (i + 1) + ": " + + Base64.getEncoder().encodeToString(multiCiphers[i])); + } + } catch (Exception e) { + e.printStackTrace(); + } + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/KeyAgreementHybridCryptosystem.java b/java/ql/test/experimental/library-tests/quantum/jca/KeyAgreementHybridCryptosystem.java new file mode 100644 index 000000000000..6f9bd06b4e77 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/KeyAgreementHybridCryptosystem.java @@ -0,0 +1,272 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +// import org.bouncycastle.pqc.jcajce.provider.BouncyCastlePQCProvider; +import java.security.*; +import java.security.spec.ECGenParameterSpec; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.KeyAgreement; +import javax.crypto.KeyGenerator; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.SecretKeyFactory; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.IvParameterSpec; +import javax.crypto.spec.PBEKeySpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * KeyAgreementHybridCryptosystem demonstrates two hybrid cryptosystems: + * + * 1. ECDH + AES-GCM: - Secure Flow: Uses ephemeral ECDH key pairs on secp256r1, + * applies a simple KDF (SHA-256) to derive a 128-bit AES key, and uses AES-GCM + * with a random 12-byte nonce. - Insecure Flow: Reuses a static key pair, uses + * raw shared secret truncation, and employs a fixed (zero) IV. + * + * 2. X25519 + ChaCha20-Poly1305: - Secure Flow: Uses ephemeral X25519 key + * pairs, applies a KDF (SHA-256) to derive a 256-bit key, and uses + * ChaCha20-Poly1305 with a random nonce. - Insecure Flow: Reuses a static key + * pair, directly truncates the shared secret without a proper KDF, and uses a + * fixed nonce. + * + * SAST/CBOM Notes: - Secure flows use proper ephemeral key generation, a simple + * KDF, and random nonces. - Insecure flows use static keys, fixed nonces, and + * raw shared secret truncation. + */ +public class KeyAgreementHybridCryptosystem { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // Security.addProvider(new BouncyCastlePQCProvider()); + // } + // ---------- Helper Methods ---------- + /** + * Generates an ephemeral ECDH key pair on secp256r1. + */ + public KeyPair generateECDHKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC"); + kpg.initialize(new ECGenParameterSpec("secp256r1"), new SecureRandom()); + return kpg.generateKeyPair(); + } + + /** + * Generates an ephemeral X25519 key pair. + */ + public KeyPair generateX25519KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("X25519", "BC"); + kpg.initialize(255, new SecureRandom()); + return kpg.generateKeyPair(); + } + + /** + * Derives a shared secret using the provided key agreement algorithm. + */ + public byte[] deriveSharedSecret(PrivateKey privateKey, PublicKey publicKey, String algorithm) throws Exception { + KeyAgreement ka = KeyAgreement.getInstance(algorithm, "BC"); + ka.init(privateKey); + ka.doPhase(publicKey, true); + return ka.generateSecret(); + } + + /** + * A simple KDF that hashes the input with SHA-256 and returns the first + * numBytes. + */ + public byte[] simpleKDF(byte[] input, int numBytes) throws Exception { + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + byte[] hash = digest.digest(input); + return Arrays.copyOf(hash, numBytes); + } + + /** + * Concatenates two byte arrays. + */ + public byte[] concatenate(byte[] a, byte[] b) { + byte[] result = new byte[a.length + b.length]; + System.arraycopy(a, 0, result, 0, a.length); + System.arraycopy(b, 0, result, a.length, b.length); + return result; + } + + // =============================================== + // 1. ECDH + AES-GCM Flows + // =============================================== + /** + * Secure hybrid encryption using ECDH and AES-GCM. Uses ephemeral key + * pairs, applies a simple KDF to derive a 128-bit AES key, and uses AES-GCM + * with a random 12-byte nonce. + */ + public byte[] secureECDH_AESGCMEncryption(byte[] plaintext) throws Exception { + KeyPair aliceKP = generateECDHKeyPair(); + KeyPair bobKP = generateECDHKeyPair(); + byte[] aliceSecret = deriveSharedSecret(aliceKP.getPrivate(), bobKP.getPublic(), "ECDH"); + byte[] aesKeyBytes = simpleKDF(aliceSecret, 16); + SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES"); + + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; + new SecureRandom().nextBytes(iv); + GCMParameterSpec spec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.ENCRYPT_MODE, aesKey, spec); + byte[] ciphertext = cipher.doFinal(plaintext); + + return concatenate(iv, ciphertext); + } + + /** + * Insecure hybrid encryption using ECDH and AES-GCM. Reuses a static key + * pair, uses raw shared secret truncation without a proper KDF, and employs + * a fixed IV (all zeros). + */ + public byte[] insecureECDH_AESGCMEncryption(byte[] plaintext) throws Exception { + KeyPair staticKP = generateECDHKeyPair(); + byte[] sharedSecret = deriveSharedSecret(staticKP.getPrivate(), staticKP.getPublic(), "ECDH"); + byte[] aesKeyBytes = Arrays.copyOf(sharedSecret, 16); + SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES"); + + byte[] fixedIV = new byte[12]; // fixed IV (all zeros) + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + GCMParameterSpec spec = new GCMParameterSpec(128, fixedIV); + cipher.init(Cipher.ENCRYPT_MODE, aesKey, spec); + byte[] ciphertext = cipher.doFinal(plaintext); + + return concatenate(fixedIV, ciphertext); + } + + // =============================================== + // 2. X25519 + ChaCha20-Poly1305 Flows + // =============================================== + /** + * Secure hybrid encryption using X25519 and ChaCha20-Poly1305. Uses + * ephemeral key pairs, applies a KDF (SHA-256) to derive a 256-bit key, and + * uses ChaCha20-Poly1305 with a random 12-byte nonce. + */ + public byte[] secureX25519_Chacha20Poly1305Encryption(byte[] plaintext) throws Exception { + KeyPair aliceKP = generateX25519KeyPair(); + KeyPair bobKP = generateX25519KeyPair(); + byte[] sharedSecret = deriveSharedSecret(aliceKP.getPrivate(), bobKP.getPublic(), "X25519"); + byte[] chachaKeyBytes = MessageDigest.getInstance("SHA-256").digest(sharedSecret); + SecretKey chachaKey = new SecretKeySpec(chachaKeyBytes, "ChaCha20"); + + Cipher cipher = Cipher.getInstance("ChaCha20-Poly1305", "BC"); + byte[] nonce = new byte[12]; + new SecureRandom().nextBytes(nonce); + cipher.init(Cipher.ENCRYPT_MODE, chachaKey, new IvParameterSpec(nonce)); + byte[] ciphertext = cipher.doFinal(plaintext); + + return concatenate(nonce, ciphertext); + } + + /** + * Insecure hybrid encryption using X25519 and ChaCha20-Poly1305. Reuses a + * static key pair, directly truncates the shared secret without a proper + * KDF, and employs a fixed nonce. + */ + public byte[] insecureX25519_Chacha20Poly1305Encryption(byte[] plaintext) throws Exception { + KeyPair staticKP = generateX25519KeyPair(); + byte[] sharedSecret = deriveSharedSecret(staticKP.getPrivate(), staticKP.getPublic(), "X25519"); + byte[] chachaKeyBytes = Arrays.copyOf(sharedSecret, 32); + SecretKey chachaKey = new SecretKeySpec(chachaKeyBytes, "ChaCha20"); + + byte[] fixedNonce = new byte[12]; // fixed nonce (all zeros) + Cipher cipher = Cipher.getInstance("ChaCha20-Poly1305", "BC"); + cipher.init(Cipher.ENCRYPT_MODE, chachaKey, new IvParameterSpec(fixedNonce)); + byte[] ciphertext = cipher.doFinal(plaintext); + + return concatenate(fixedNonce, ciphertext); + } + + // =============================================== + // 3. Dynamic Hybrid Selection + // =============================================== + /** + * Dynamically selects a hybrid encryption flow based on a configuration + * property. If the config is unknown, defaults to an insecure flow. + */ + public String dynamicHybridEncryption(String config, byte[] plaintext) throws Exception { + byte[] result; + if ("secureECDH".equalsIgnoreCase(config)) { + result = secureECDH_AESGCMEncryption(plaintext); + } else if ("insecureECDH".equalsIgnoreCase(config)) { + result = insecureECDH_AESGCMEncryption(plaintext); + } else if ("secureX25519".equalsIgnoreCase(config)) { + result = secureX25519_Chacha20Poly1305Encryption(plaintext); + } else if ("insecureX25519".equalsIgnoreCase(config)) { + result = insecureX25519_Chacha20Poly1305Encryption(plaintext); + } else { + // Fallback to insecure ECDH flow. + result = insecureECDH_AESGCMEncryption(plaintext); + } + return Base64.getEncoder().encodeToString(result); + } + + // =============================================== + // 4. Further Key Derivation from Symmetric Keys + // =============================================== + /** + * Derives two keys from a symmetric key using PBKDF2, then uses one key for + * AES-GCM encryption and the other for computing a MAC over the ciphertext. + */ + public byte[] furtherUseSymmetricKeyForKeyDerivation(SecretKey key, byte[] plaintext) throws Exception { + String keyAsString = Base64.getEncoder().encodeToString(key.getEncoded()); + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(keyAsString.toCharArray(), salt, 10000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] derived = factory.generateSecret(spec).getEncoded(); + byte[] encKeyBytes = Arrays.copyOfRange(derived, 0, 16); + byte[] macKeyBytes = Arrays.copyOfRange(derived, 16, 32); + SecretKey encryptionKey = new SecretKeySpec(encKeyBytes, "AES"); + SecretKey derivedMacKey = new SecretKeySpec(macKeyBytes, "HmacSHA256"); + + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; + new SecureRandom().nextBytes(iv); + GCMParameterSpec specGcm = new GCMParameterSpec(128, iv); + cipher.init(Cipher.ENCRYPT_MODE, encryptionKey, specGcm); + byte[] ciphertext = cipher.doFinal(plaintext); + + Mac mac = Mac.getInstance("HmacSHA256"); + mac.init(derivedMacKey); + byte[] computedMac = mac.doFinal(ciphertext); + + byte[] output = new byte[ciphertext.length + computedMac.length]; + System.arraycopy(ciphertext, 0, output, 0, ciphertext.length); + System.arraycopy(computedMac, 0, output, ciphertext.length, computedMac.length); + storeOutput(output); + return output; + } + + // =============================================== + // 5. Output/Storage Methods + // =============================================== + /** + * Stores the output securely. + */ + public void storeOutput(byte[] output) { + String stored = Base64.getEncoder().encodeToString(output); + // In production, this value would be stored or transmitted securely. + } + + // =============================================== + // 6. Helper Methods for Key/Nonce Generation + // =============================================== + /** + * Generates a secure 256-bit AES key. + */ + public SecretKey generateAESKey() throws Exception { + KeyGenerator kg = KeyGenerator.getInstance("AES"); + kg.init(256, new SecureRandom()); + return kg.generateKey(); + } + + /** + * Generates a random salt. + */ + private byte[] generateSalt(int length) { + byte[] salt = new byte[length]; + new SecureRandom().nextBytes(salt); + return salt; + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/KeyArtifact.java b/java/ql/test/experimental/library-tests/quantum/jca/KeyArtifact.java new file mode 100644 index 000000000000..4c80246050a4 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/KeyArtifact.java @@ -0,0 +1,85 @@ +package com.example.crypto.artifacts; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.io.FileInputStream; +import java.security.*; +import java.security.spec.*; +import java.util.Properties; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; + +public class KeyArtifact { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + public void generateSymmetricKeys() throws NoSuchAlgorithmException { + // AES Key Generation (Default Provider) + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); + SecretKey aesKeyJDK = keyGen.generateKey(); + + // AES Key Generation (BouncyCastle) + keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); + SecretKey aesKeyBC = keyGen.generateKey(); + } + + public void generateAsymmetricKeys() throws NoSuchAlgorithmException { + // RSA Key Generation (JDK Default) + KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA"); + keyPairGen.initialize(2048); + KeyPair rsaPairJDK = keyPairGen.generateKeyPair(); + + // RSA Key Generation (BouncyCastle) + keyPairGen = KeyPairGenerator.getInstance("RSA"); + keyPairGen.initialize(2048); + KeyPair rsaPairBC = keyPairGen.generateKeyPair(); + + // EC Key Generation + keyPairGen = KeyPairGenerator.getInstance("EC"); + keyPairGen.initialize(256); + KeyPair ecPair = keyPairGen.generateKeyPair(); + } + + public void importExportRSAKeys(KeyPair keyPair) throws NoSuchAlgorithmException, InvalidKeySpecException { + // Export Public Key + byte[] pubKeyBytes = keyPair.getPublic().getEncoded(); + X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(pubKeyBytes); + KeyFactory keyFactory = KeyFactory.getInstance("RSA"); + PublicKey importedPubKey = keyFactory.generatePublic(pubKeySpec); + + // Export Private Key + byte[] privKeyBytes = keyPair.getPrivate().getEncoded(); + PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(privKeyBytes); + PrivateKey importedPrivKey = keyFactory.generatePrivate(privKeySpec); + } + + public void dynamicAlgorithmSelection() throws Exception { + // Load algorithm from configuration + Properties properties = new Properties(); + properties.load(new FileInputStream("crypto-config.properties")); + String algorithm = properties.getProperty("key.algorithm", "AES"); + + KeyGenerator keyGen = KeyGenerator.getInstance(algorithm); + keyGen.init(256); + SecretKey dynamicKey = keyGen.generateKey(); + } + + public KeyPair generateKeyPair(String algorithm) throws NoSuchAlgorithmException { + // Wrapper for Key Generation + KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(algorithm); + keyPairGen.initialize(2048); + return keyPairGen.generateKeyPair(); + } + + public void keySelectionFromArray() throws NoSuchAlgorithmException { + // Selecting Algorithm Dynamically from an Array + String[] algorithms = {"RSA", "EC", "Ed25519"}; + KeyPair[] keyPairs = new KeyPair[algorithms.length]; + + for (int i = 0; i < algorithms.length; i++) { + keyPairs[i] = generateKeyPair(algorithms[i]); + } + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/KeyDerivation1.java b/java/ql/test/experimental/library-tests/quantum/jca/KeyDerivation1.java new file mode 100644 index 000000000000..a97f02f18c1d --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/KeyDerivation1.java @@ -0,0 +1,368 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.crypto.generators.Argon2BytesGenerator; +// import org.bouncycastle.crypto.params.Argon2Parameters; +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.io.FileInputStream; +import java.io.IOException; +import java.security.MessageDigest; +import java.security.SecureRandom; +import java.util.Arrays; +import java.util.Base64; +import java.util.Properties; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.SecretKeyFactory; +import javax.crypto.spec.PBEKeySpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * This class demonstrates multiple key derivation functions (KDFs) including + * PBKDF2, scrypt, Argon2, raw hash derivation, HKDF, and dynamic algorithm + * selection. + * + * SAST/CBOM Classification Notes: + * + * 1. PBKDF2 Examples: - Parent Classification: Password-Based Key Derivation + * Function (PBKDF). - SAST: * pbkdf2DerivationBasic: Uses PBKDF2WithHmacSHA256 + * with 10,000 iterations - acceptable if parameters meet current standards. * + * pbkdf2LowIteration: Uses only 10 iterations, flagged as insecure due to + * insufficient iteration count. * pbkdf2HighIteration: Uses 1,000,000 + * iterations - secure (though performance may be impacted). * pbkdf2HmacSHA1: + * Uses PBKDF2WithHmacSHA1 - flagged as weaker compared to SHA-256, though + * sometimes seen in legacy systems. * pbkdf2HmacSHA512: Uses + * PBKDF2WithHmacSHA512 - classified as secure. + * + * 2. Scrypt Examples: - Parent Classification: Memory-Hard Key Derivation + * Function. - SAST: * scryptWeak: Uses weak parameters (n=1024, r=1, p=1) - + * flagged as insecure. * scryptStrong: Uses stronger parameters (n=16384, r=8, + * p=1) - considered secure. + * + * 3. Argon2 Examples: - Parent Classification: Memory-Hard Key Derivation + * Function (Argon2id). - SAST: * argon2Derivation: Uses moderate memory and + * iterations - considered secure. * argon2HighMemory: Uses high memory (128MB) + * and more iterations - secure, though resource intensive. + * + * 4. Insecure Raw Hash Derivation: - Parent Classification: Raw Hash Usage for + * Key Derivation. - SAST: Using a single SHA-256 hash as a key and then using + * it with insecure AES/ECB mode is highly discouraged. + * + * 5. HKDF Examples: - Parent Classification: Key Derivation Function (HKDF). - + * SAST: The provided HKDF implementation is simplistic (single-block expansion) + * and may be flagged. + * + * 6. Multi-Step Hybrid Derivation: - Parent Classification: Composite KDF + * (PBKDF2 followed by HKDF). - SAST: Combining two KDFs is acceptable if done + * carefully; however, custom implementations should be reviewed. + * + * 7. Dynamic KDF Selection: - Parent Classification: Dynamic/Configurable Key + * Derivation. - SAST: Loading KDF parameters from configuration introduces + * ambiguity and risk if misconfigured. + */ +public class KeyDerivation1 { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + ////////////////////////////////////// + // 1. PBKDF2 EXAMPLES + ////////////////////////////////////// + + /** + * Basic PBKDF2 derivation using PBKDF2WithHmacSHA256. + * + * SAST/CBOM: + * - Parent: PBKDF2. + * - Uses 10,000 iterations with a 256-bit key; generally acceptable. + */ + public void pbkdf2DerivationBasic(String password) throws Exception { + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 10000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] key = factory.generateSecret(spec).getEncoded(); + System.out.println("PBKDF2 (Basic) Key: " + Base64.getEncoder().encodeToString(key)); + } + + /** + * PBKDF2 derivation with a very low iteration count. + * + * SAST/CBOM: - Parent: PBKDF2. - Iteration count is only 10, which is far + * below acceptable security standards. - Flagged as insecure. + */ + public void pbkdf2LowIteration(String password) throws Exception { + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 10, 256); // Very low iteration count. + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] key = factory.generateSecret(spec).getEncoded(); + System.out.println("PBKDF2 (Low Iteration) Key (Insecure): " + Base64.getEncoder().encodeToString(key)); + } + + /** + * PBKDF2 derivation with a high iteration count. + * + * SAST/CBOM: - Parent: PBKDF2. - Uses 1,000,000 iterations; this is secure + * but may impact performance. + */ + public void pbkdf2HighIteration(String password) throws Exception { + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 1_000_000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] key = factory.generateSecret(spec).getEncoded(); + System.out.println("PBKDF2 (High Iteration) Key: " + Base64.getEncoder().encodeToString(key)); + } + + /** + * PBKDF2 derivation using HmacSHA1. + * + * SAST/CBOM: - Parent: PBKDF2. - Uses HMAC-SHA1, which is considered weaker + * than SHA-256; may be acceptable only for legacy systems. + */ + public void pbkdf2HmacSHA1(String password) throws Exception { + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 80000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA1"); + byte[] key = factory.generateSecret(spec).getEncoded(); + System.out.println("PBKDF2 (HmacSHA1) Key: " + Base64.getEncoder().encodeToString(key)); + } + + /** + * PBKDF2 derivation using HmacSHA512. + * + * SAST/CBOM: - Parent: PBKDF2. - Uses HMAC-SHA512 with 160,000 iterations; + * classified as secure. + */ + public void pbkdf2HmacSHA512(String password) throws Exception { + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 160000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512"); + byte[] key = factory.generateSecret(spec).getEncoded(); + System.out.println("PBKDF2 (HmacSHA512) Key: " + Base64.getEncoder().encodeToString(key)); + } + + ////////////////////////////////////// + // 2. SCRYPT EXAMPLES + ////////////////////////////////////// + + /** + * Scrypt derivation with weak parameters. + * + * SAST/CBOM: + * - Parent: Scrypt. + * - Parameters (n=1024, r=1, p=1) are too weak and should be flagged as + * insecure. + */ + public void scryptWeak(String password) throws Exception { + byte[] salt = generateSalt(16); + // Weak parameters: low work factor. + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 1024, 128); + SecretKeyFactory factory = SecretKeyFactory.getInstance("SCRYPT"); + byte[] key = factory.generateSecret(spec).getEncoded(); + System.out.println("scrypt (Weak) Key: " + Base64.getEncoder().encodeToString(key)); + } + + /** + * Scrypt derivation with stronger parameters. + * + * SAST/CBOM: - Parent: Scrypt. - Parameters (n=16384, r=8, p=1) provide a + * secure work factor. + */ + public void scryptStrong(String password) throws Exception { + byte[] salt = generateSalt(16); + // Strong parameters for scrypt. + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 16384, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("SCRYPT"); + byte[] key = factory.generateSecret(spec).getEncoded(); + System.out.println("scrypt (Strong) Key: " + Base64.getEncoder().encodeToString(key)); + } + + ////////////////////////////////////// + // 3. ARGON2 EXAMPLES + ////////////////////////////////////// + + // /** + // * Argon2 derivation using Argon2id with moderate memory and iterations. + // * + // * SAST/CBOM: + // * - Parent: Argon2 (Memory-Hard KDF). + // * - Parameters: memory=65536 KB, iterations=2, parallelism=2; considered + // * secure. + // */ + // public void argon2Derivation(String password) throws Exception { + // byte[] salt = generateSalt(16); + // Argon2Parameters.Builder builder = new Argon2Parameters.Builder(Argon2Parameters.ARGON2_id) + // .withSalt(salt) + // .withParallelism(2) + // .withMemoryAsKB(65536) + // .withIterations(2); + + // Argon2BytesGenerator gen = new Argon2BytesGenerator(); + // gen.init(builder.build()); + // byte[] hash = new byte[32]; + // gen.generateBytes(password.getBytes(), hash, 0, hash.length); + // System.out.println("Argon2 Key: " + Base64.getEncoder().encodeToString(hash)); + // } + + // /** + // * Argon2 derivation with high memory and more iterations. + // * + // * SAST/CBOM: + // * - Parent: Argon2. + // * - Uses high memory (131072 KB = 128MB) and 5 iterations; secure but resource + // * intensive. + // */ + // public void argon2HighMemory(String password) throws Exception { + // byte[] salt = generateSalt(16); + // Argon2Parameters.Builder builder = new Argon2Parameters.Builder(Argon2Parameters.ARGON2_id) + // .withSalt(salt) + // .withParallelism(4) + // .withMemoryAsKB(131072) // 128MB of memory. + // .withIterations(5); + + // Argon2BytesGenerator gen = new Argon2BytesGenerator(); + // gen.init(builder.build()); + // byte[] hash = new byte[64]; + // gen.generateBytes(password.getBytes(), hash, 0, hash.length); + // System.out.println("Argon2 (High Memory) Key: " + Base64.getEncoder().encodeToString(hash)); + // } + + ////////////////////////////////////// + // 4. INSECURE RAW HASH EXAMPLES + ////////////////////////////////////// + + /** + * Derives a key by directly hashing input with SHA-256 and uses it for + * encryption. + * + * SAST/CBOM: + * - Parent: Raw Hash-Based Key Derivation. + * - This approach is insecure since it uses a raw hash as a key and then uses + * AES in ECB mode, + * which is vulnerable to pattern analysis. + */ + public void insecureRawSHA256Derivation(String input) throws Exception { + MessageDigest digest = MessageDigest.getInstance("SHA-256"); + byte[] derivedKey = digest.digest(input.getBytes()); + System.out.println("Insecure Raw SHA-256 Key: " + Base64.getEncoder().encodeToString(derivedKey)); + + // Insecure usage: AES/ECB mode is used with a key derived from a raw hash. + SecretKey key = new SecretKeySpec(derivedKey, 0, 16, "AES"); + javax.crypto.Cipher cipher = javax.crypto.Cipher.getInstance("AES/ECB/NoPadding"); + cipher.init(javax.crypto.Cipher.ENCRYPT_MODE, key); + byte[] ciphertext = cipher.doFinal("SampleData16Bytes".getBytes()); + System.out.println("Insecurely Encrypted Data with Raw-SHA256 Key: " + + Base64.getEncoder().encodeToString(ciphertext)); + } + + ////////////////////////////////////// + // 5. HKDF EXAMPLES + ////////////////////////////////////// + + /** + * Derives a key using a simple HKDF expansion based on HMAC-SHA256. + * + * SAST/CBOM: + * - Parent: HKDF. + * - The implementation uses a single-block (simplistic) expansion and may be + * flagged. + * A full, standard HKDF implementation is recommended. + */ + public void hkdfDerivation(byte[] ikm) throws Exception { + byte[] salt = generateSalt(32); + byte[] derivedKey = hkdfExpand(ikm, salt, 32); + System.out.println("HKDF Derived Key: " + Base64.getEncoder().encodeToString(derivedKey)); + } + + /** + * Multi-step hybrid derivation: first using PBKDF2, then applying HKDF + * expansion. + * + * SAST/CBOM: - Parent: Composite KDF. - Combining PBKDF2 and HKDF is a + * non-standard approach and may be flagged; ensure that each step meets + * security requirements. + */ + public void multiStepHybridDerivation(String password, byte[] sharedSecret) throws Exception { + byte[] pbkdf2Key = derivePBKDF2Key(password); + byte[] finalKey = hkdfExpand(sharedSecret, pbkdf2Key, 32); + System.out.println("Multi-Step Hybrid Key: " + Base64.getEncoder().encodeToString(finalKey)); + } + + ////////////////////////////////////// + // 6. DYNAMIC ALGORITHM SELECTION (AMBIGUOUS CASE) + ////////////////////////////////////// + + /** + * Dynamically selects a KDF algorithm based on external configuration. + * + * SAST/CBOM: + * - Parent: Dynamic/Configurable Key Derivation. + * - Loading the algorithm and parameters from a config file introduces risk if + * the configuration is compromised + * or misconfigured. + */ + public void dynamicKDFSelection(String password, String configPath) throws Exception { + Properties props = new Properties(); + try (FileInputStream fis = new FileInputStream(configPath)) { + props.load(fis); + } catch (IOException e) { + e.printStackTrace(); + } + String kdfAlg = props.getProperty("kdf.alg", "PBKDF2WithHmacSHA256"); + int iterations = Integer.parseInt(props.getProperty("kdf.iterations", "10000")); + int keySize = Integer.parseInt(props.getProperty("kdf.keySize", "256")); + + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, iterations, keySize); + SecretKeyFactory factory = SecretKeyFactory.getInstance(kdfAlg); + byte[] derived = factory.generateSecret(spec).getEncoded(); + System.out.println("Dynamically Selected KDF (" + kdfAlg + ") Key: " + + Base64.getEncoder().encodeToString(derived)); + } + + ////////////////////////////////////// + // HELPER METHODS + ////////////////////////////////////// + + /** + * Helper method to derive a PBKDF2 key with PBKDF2WithHmacSHA256. + * + * SAST/CBOM: + * - Parent: PBKDF2 helper. + */ + private byte[] derivePBKDF2Key(String password) throws Exception { + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 10000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + return factory.generateSecret(spec).getEncoded(); + } + + /** + * A simplistic HKDF expansion function using HMAC-SHA256. + * + * SAST/CBOM: - Parent: HKDF. - Uses a single-block expansion + * ("hkdf-expansion") which is non-standard and may be flagged. + */ + private byte[] hkdfExpand(byte[] ikm, byte[] salt, int length) throws Exception { + Mac hmac = Mac.getInstance("HmacSHA256"); + SecretKey secretKey = new SecretKeySpec(salt, "HmacSHA256"); + hmac.init(secretKey); + byte[] prk = hmac.doFinal(ikm); // Extraction step. + + // Single-block expansion (non-standard; for full HKDF, multiple iterations may + // be necessary) + hmac.init(new SecretKeySpec(prk, "HmacSHA256")); + byte[] okm = hmac.doFinal("hkdf-expansion".getBytes()); + return Arrays.copyOf(okm, length); + } + + /** + * Generates a secure random salt of the specified length. + * + * SAST/CBOM: - Parent: Secure Random Salt Generation. - Uses SecureRandom; + * considered best practice. + */ + private byte[] generateSalt(int length) { + byte[] salt = new byte[length]; + new SecureRandom().nextBytes(salt); + return salt; + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/KeyEncapsulation.java b/java/ql/test/experimental/library-tests/quantum/jca/KeyEncapsulation.java new file mode 100644 index 000000000000..df787496d779 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/KeyEncapsulation.java @@ -0,0 +1,229 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +// import org.bouncycastle.pqc.jcajce.provider.BouncyCastlePQCProvider; +// import org.bouncycastle.pqc.jcajce.spec.KyberParameterSpec; +// import org.bouncycastle.util.Strings; +import java.security.*; +import java.security.spec.ECGenParameterSpec; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.KeyAgreement; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * Demonstrates various Key Encapsulation Mechanisms (KEMs), including: + * + * 1) RSA-KEM (emulated using RSA-OAEP for ephemeral key wrapping) - CBOM/SAST: + * Classified as a Hybrid Cryptosystem (public-key based key encapsulation). + * While RSA-OAEP is secure, using it to emulate KEM (without a standard scheme) + * may be flagged. + * + * 2) ECIES (Elliptic Curve Integrated Encryption Scheme) - CBOM/SAST: + * Classified as a Hybrid Cryptosystem (KEM+DEM) based on ECDH and AES. Note: + * Directly using the raw ECDH shared secret as key material is insecure in + * production. + * + * 3) Kyber (Post-Quantum KEM using BouncyCastle PQC) - CBOM/SAST: Classified as + * a Post-Quantum Key Encapsulation mechanism. This is modern and secure when + * using standardized parameters. + * + * 4) Basic ephemeral flows that mimic KEM logic using ephemeral ECDH. - + * CBOM/SAST: Classified as a simple KEM mimic based on ephemeral ECDH. + */ +public class KeyEncapsulation { + + // static { + // // Adding both classical and PQC providers. + // Security.addProvider(new BouncyCastleProvider()); + // Security.addProvider(new BouncyCastlePQCProvider()); + // } + ////////////////////////////////////// + // 1. RSA-KEM-Like Flow + ////////////////////////////////////// + + /** + * Emulates RSA-KEM by using RSA-OAEP to wrap a random AES key. + * + * SAST/CBOM Classification: + * - Parent: Hybrid Cryptosystem (RSA-OAEP based key encapsulation). + * - Note: Although RSA-OAEP is secure, using it to "wrap" an ephemeral key is a + * non-standard KEM pattern. + * + * @param rsaPub The RSA public key of the recipient. + */ + public void rsaKEMEncapsulation(PublicKey rsaPub) throws Exception { + // 1) Generate an ephemeral AES key (symmetric key for data encryption) + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); // 256-bit AES key. + SecretKey aesKey = keyGen.generateKey(); + System.out.println("Ephemeral AES Key: " + Base64.getEncoder().encodeToString(aesKey.getEncoded())); + + // 2) Encrypt (wrap) the ephemeral AES key with RSA-OAEP. + // SAST Note: This RSA-OAEP wrapping is used to encapsulate the AES key. + Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); + rsaCipher.init(Cipher.ENCRYPT_MODE, rsaPub); + byte[] wrappedKey = rsaCipher.doFinal(aesKey.getEncoded()); + System.out.println("RSA-KEM Encapsulated AES Key: " + Base64.getEncoder().encodeToString(wrappedKey)); + + // 3) Example usage: Encrypt data with the ephemeral AES key using AES-GCM. + Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; // Standard IV length for GCM. + new SecureRandom().nextBytes(iv); + GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv); + aesCipher.init(Cipher.ENCRYPT_MODE, aesKey, gcmSpec); + byte[] ciphertext = aesCipher.doFinal("KEM-based encryption".getBytes()); + System.out.println("AES-GCM ciphertext: " + Base64.getEncoder().encodeToString(ciphertext)); + } + + /** + * Performs RSA decapsulation by decrypting the wrapped AES key. + * + * SAST/CBOM Classification: - Parent: Hybrid Cryptosystem (RSA-OAEP based + * key decapsulation). - Note: Secure when used with matching RSA key pairs. + * + * @param rsaPriv The RSA private key corresponding to the public key used. + * @param wrappedKey The RSA-wrapped ephemeral AES key. + */ + public void rsaKEMDecapsulation(PrivateKey rsaPriv, byte[] wrappedKey) throws Exception { + Cipher rsaCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); + rsaCipher.init(Cipher.DECRYPT_MODE, rsaPriv); + byte[] aesKeyBytes = rsaCipher.doFinal(wrappedKey); + SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES"); + System.out.println("RSA-KEM Decapsulated AES Key: " + Base64.getEncoder().encodeToString(aesKey.getEncoded())); + } + + ////////////////////////////////////// + // 2. ECIES Example + ////////////////////////////////////// + + /** + * Implements a simplified ECIES flow using ephemeral ECDH and AES-GCM. + * + * SAST/CBOM Classification: + * - Parent: Hybrid Cryptosystem (ECIES: ECDH-based key encapsulation + DEM). + * - Note: Directly using the raw ECDH shared secret as key material is + * insecure. + * In practice, a proper KDF must be applied. + * + * @param ecPub The recipient's EC public key. + */ + public void eciesEncapsulation(PublicKey ecPub) throws Exception { + // Generate an ephemeral EC key pair. + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC"); + kpg.initialize(new ECGenParameterSpec("secp256r1"), new SecureRandom()); + KeyPair ephemeralEC = kpg.generateKeyPair(); + + // Perform ECDH key agreement to derive the shared secret. + KeyAgreement ka = KeyAgreement.getInstance("ECDH"); + ka.init(ephemeralEC.getPrivate()); + ka.doPhase(ecPub, true); + byte[] sharedSecret = ka.generateSecret(); + System.out.println("ECIES ephemeral ECDH Secret: " + Base64.getEncoder().encodeToString(sharedSecret)); + + // For demonstration only: directly use part of the shared secret as an AES key. + // SAST Note: This is insecure; a proper key derivation function (KDF) must be + // used. + SecretKey aesKey = new SecretKeySpec(sharedSecret, 0, 16, "AES"); + + // Encrypt the message using AES-GCM. + Cipher aesCipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; + new SecureRandom().nextBytes(iv); + aesCipher.init(Cipher.ENCRYPT_MODE, aesKey, new GCMParameterSpec(128, iv)); + byte[] ciphertext = aesCipher.doFinal("ECIES message".getBytes()); + + // The ephemeral public key (ephemeralEC.getPublic()) is transmitted as part of + // the output. + System.out.println( + "ECIES ephemeral public: " + Base64.getEncoder().encodeToString(ephemeralEC.getPublic().getEncoded())); + System.out.println("ECIES ciphertext: " + Base64.getEncoder().encodeToString(ciphertext)); + } + + ////////////////////////////////////// + // 3. Kyber Example (Post-Quantum KEM) + ////////////////////////////////////// + + // /** + // * Demonstrates a Kyber-based encapsulation using BouncyCastle's PQC provider. + // * + // * SAST/CBOM Classification: + // * - Parent: Post-Quantum KEM. + // * - Note: Kyber is a modern, post-quantum secure KEM. This example uses + // * Kyber-512. + // * + // * @param kyberRecipientKP The recipient's Kyber key pair. + // */ + // public void kyberEncapsulate(KeyPair kyberRecipientKP) throws Exception { + // // Use an ephemeral label for demonstration. + // byte[] ephemeralLabel = Strings.toByteArray("Kyber-KEM-Label"); + // Cipher kemCipher = Cipher.getInstance("Kyber", "BCPQC"); + // kemCipher.init(Cipher.ENCRYPT_MODE, kyberRecipientKP.getPublic(), new SecureRandom()); + // byte[] ciphertext = kemCipher.doFinal(ephemeralLabel); + // System.out.println("Kyber ciphertext: " + Base64.getEncoder().encodeToString(ciphertext)); + // } + + ////////////////////////////////////// + // 4. Basic Ephemeral Flows That Mimic KEM + ////////////////////////////////////// + + /** + * Uses ephemeral ECDH to derive a shared secret that mimics a KEM. + * + * SAST/CBOM Classification: + * - Parent: Ephemeral Key Agreement (mimicking KEM). + * - Note: This simple approach demonstrates the concept of using ephemeral keys + * to derive a secret. + * In a full scheme, the ephemeral public key would also be transmitted. + * + * @param recipientPubKey The recipient's public key. + */ + public void ephemeralECDHMimicKEM(PublicKey recipientPubKey) throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC"); + kpg.initialize(new ECGenParameterSpec("secp256r1")); + KeyPair ephemeralKP = kpg.generateKeyPair(); + KeyAgreement ka = KeyAgreement.getInstance("ECDH"); + ka.init(ephemeralKP.getPrivate()); + ka.doPhase(recipientPubKey, true); + byte[] sharedSecret = ka.generateSecret(); + System.out.println( + "Ephemeral ECDH shared secret (mimics KEM): " + Base64.getEncoder().encodeToString(sharedSecret)); + // In a full implementation, the ephemeral public key and the shared secret are + // used together. + } + + ////////////////////////////////////// + // Test / Demo Method + ////////////////////////////////////// + + /** + * Demonstrates each of the key encapsulation flows. + */ + public void runKeyEncapsulationDemos() throws Exception { + // 1) RSA-KEM-like Flow: + KeyPairGenerator rsaKpg = KeyPairGenerator.getInstance("RSA"); + rsaKpg.initialize(2048); + KeyPair rsaKP = rsaKpg.generateKeyPair(); + rsaKEMEncapsulation(rsaKP.getPublic()); + + // 2) ECIES Example: + KeyPairGenerator ecKpg = KeyPairGenerator.getInstance("EC"); + ecKpg.initialize(new ECGenParameterSpec("secp256r1")); + KeyPair ecKP = ecKpg.generateKeyPair(); + eciesEncapsulation(ecKP.getPublic()); + + // // 3) Kyber Example (Post-Quantum KEM): + // KeyPairGenerator kyberKpg = KeyPairGenerator.getInstance("Kyber", "BCPQC"); + // kyberKpg.initialize(KyberParameterSpec.kyber512); + // KeyPair kyberKP = kyberKpg.generateKeyPair(); + // kyberEncapsulate(kyberKP); + // 4) Ephemeral ECDH Mimic KEM: + // For demonstration, we use an EC key pair and mimic KEM by deriving a shared + // secret. + KeyPair ephemeralEC = ecKpg.generateKeyPair(); + ephemeralECDHMimicKEM(ephemeralEC.getPublic()); + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/KeyExchange.java b/java/ql/test/experimental/library-tests/quantum/jca/KeyExchange.java new file mode 100644 index 000000000000..ef4d5b94c86f --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/KeyExchange.java @@ -0,0 +1,330 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; +import java.security.spec.ECGenParameterSpec; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.KeyAgreement; + +/** + * Demonstrates various Key Exchange mechanisms using standard Java and + * BouncyCastle: + * + * 1) Classic DH (Diffie-Hellman) with multiple key sizes: - 512-bit: + * Insecure/deprecated (flagged as unsafe by SAST). - 2048-bit: Standard secure + * level. - 4096-bit: High-security (but can be slow). + * + * 2) ECDH (using secp256r1): - Classified as a secure elliptic-curve key + * exchange. + * + * 3) X25519: - A modern and efficient elliptic-curve key exchange protocol. + * + * 4) X448: - Provides a higher security level for key exchange. + * + * In addition, the class now includes a nuanced insecure example that + * demonstrates: - Reusing static key pairs instead of generating fresh + * ephemeral keys. - Using weak parameters (512-bit DH) in a key exchange. + * + * The runAllExchanges() method demonstrates generating keys for each algorithm, + * deriving shared secrets, and comparing safe vs. insecure practices. + */ +public class KeyExchange { + + // static { + // // Add the BouncyCastle provider to support additional algorithms. + // Security.addProvider(new BouncyCastleProvider()); + // } + ////////////////////////////////////////// + // 1. Classic DH (Diffie-Hellman) + ////////////////////////////////////////// + + /** + * Generates a standard Diffie-Hellman key pair using a 2048-bit modulus. + * + * CBOM/SAST Classification: + * - Parent: Classic Diffie-Hellman Key Exchange. + * - 2048-bit is considered secure and is widely accepted. + * + * @return A 2048-bit DH KeyPair. + */ + public KeyPair generateDHKeyPair() throws Exception { + KeyPairGenerator dhKpg = KeyPairGenerator.getInstance("DH"); + dhKpg.initialize(2048); + return dhKpg.generateKeyPair(); + } + + /** + * Generates a deprecated/unsafe Diffie-Hellman key pair using a 512-bit + * modulus. + * + * CBOM/SAST Classification: - Parent: Classic Diffie-Hellman Key Exchange. + * - 512-bit DH is considered insecure and should be flagged by SAST tools. + * + * @return A 512-bit (insecure) DH KeyPair. + */ + public KeyPair generateDHDeprecated() throws Exception { + KeyPairGenerator dhKpg = KeyPairGenerator.getInstance("DH"); + // 512 bits is considered insecure/deprecated. + dhKpg.initialize(512); + return dhKpg.generateKeyPair(); + } + + /** + * Generates a high-security Diffie-Hellman key pair using a 4096-bit + * modulus. + * + * CBOM/SAST Classification: - Parent: Classic Diffie-Hellman Key Exchange. + * - 4096-bit DH offers high security, though it may be slower in practice. + * + * @return A 4096-bit DH KeyPair. + */ + public KeyPair generateDHHighSecurity() throws Exception { + KeyPairGenerator dhKpg = KeyPairGenerator.getInstance("DH"); + dhKpg.initialize(4096); + return dhKpg.generateKeyPair(); + } + + /** + * Derives a shared secret from a DH key pair. + * + * CBOM/SAST Classification: - Parent: Classic Diffie-Hellman Key Exchange. + * - Properly deriving the shared secret is secure if using a safe key size. + * + * @param privateKey The private key of one party. + * @param publicKey The public key of the other party. + * @return The derived shared secret as a byte array. + */ + public byte[] deriveDHSecret(PrivateKey privateKey, PublicKey publicKey) throws Exception { + KeyAgreement ka = KeyAgreement.getInstance("DH"); + ka.init(privateKey); + ka.doPhase(publicKey, true); + return ka.generateSecret(); + } + + ////////////////////////////////////////// + // 2. ECDH (secp256r1) + ////////////////////////////////////////// + + /** + * Generates an Elliptic Curve Diffie-Hellman key pair using the secp256r1 + * curve. + * + * CBOM/SAST Classification: + * - Parent: Elliptic Curve Diffie-Hellman (ECDH). + * - secp256r1 is widely regarded as secure and efficient. + * + * @return An ECDH KeyPair on secp256r1. + */ + public KeyPair generateECDHKeyPair() throws Exception { + KeyPairGenerator ecKpg = KeyPairGenerator.getInstance("EC", "BC"); + ecKpg.initialize(new ECGenParameterSpec("secp256r1"), new SecureRandom()); + return ecKpg.generateKeyPair(); + } + + /** + * Derives a shared secret using ECDH. + * + * CBOM/SAST Classification: - Parent: Elliptic Curve Diffie-Hellman (ECDH). + * - Secure when using appropriate curves and proper randomness. + * + * @param privateKey The ECDH private key. + * @param publicKey The corresponding public key. + * @return The derived ECDH shared secret. + */ + public byte[] deriveECDHSecret(PrivateKey privateKey, PublicKey publicKey) throws Exception { + KeyAgreement ka = KeyAgreement.getInstance("ECDH", "BC"); + ka.init(privateKey); + ka.doPhase(publicKey, true); + return ka.generateSecret(); + } + + ////////////////////////////////////////// + // 3. X25519 + ////////////////////////////////////////// + + /** + * Generates an ephemeral X25519 key pair. + * + * CBOM/SAST Classification: + * - Parent: Modern Elliptic-Curve Key Exchange. + * - X25519 is considered secure and efficient. + * + * @return An X25519 KeyPair. + */ + public KeyPair generateX25519KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("X25519", "BC"); + // X25519 key size is fixed; the parameter (255) is a reference value. + kpg.initialize(255, new SecureRandom()); + return kpg.generateKeyPair(); + } + + /** + * Derives a shared secret using the X25519 key agreement. + * + * CBOM/SAST Classification: - Parent: Modern Elliptic-Curve Key Exchange. - + * X25519 is highly recommended for its security and efficiency. + * + * @param privateKey The X25519 private key. + * @param publicKey The corresponding public key. + * @return The derived X25519 shared secret. + */ + public byte[] deriveX25519Secret(PrivateKey privateKey, PublicKey publicKey) throws Exception { + KeyAgreement ka = KeyAgreement.getInstance("X25519", "BC"); + ka.init(privateKey); + ka.doPhase(publicKey, true); + return ka.generateSecret(); + } + + ////////////////////////////////////////// + // 4. X448 + ////////////////////////////////////////// + + /** + * Generates an ephemeral X448 key pair. + * + * CBOM/SAST Classification: + * - Parent: Modern Elliptic-Curve Key Exchange. + * - X448 provides a higher security margin than X25519. + * + * @return An X448 KeyPair. + */ + public KeyPair generateX448KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("X448", "BC"); + // X448 key size is fixed; the parameter (448) is the curve parameter. + kpg.initialize(448, new SecureRandom()); + return kpg.generateKeyPair(); + } + + /** + * Derives a shared secret using the X448 key agreement. + * + * CBOM/SAST Classification: - Parent: Modern Elliptic-Curve Key Exchange. - + * X448 is considered secure and suitable for high-security applications. + * + * @param privateKey The X448 private key. + * @param publicKey The corresponding public key. + * @return The derived X448 shared secret. + */ + public byte[] deriveX448Secret(PrivateKey privateKey, PublicKey publicKey) throws Exception { + KeyAgreement ka = KeyAgreement.getInstance("X448", "BC"); + ka.init(privateKey); + ka.doPhase(publicKey, true); + return ka.generateSecret(); + } + + ////////////////////////////////////////// + // 5. Nuanced Insecure Key Exchange Example + ////////////////////////////////////////// + + /** + * Demonstrates a nuanced example of insecure key exchange by: + * - Using deprecated DH parameters (512-bit). + * - Reusing static (non-ephemeral) keys. + * + * SAST/CBOM Classification: + * - Parent: Insecure Key Exchange Patterns. + * - Issues: + * * 512-bit DH is weak and vulnerable to attacks. + * * Reusing a static key pair across sessions eliminates forward secrecy. + * * Reusing an ECDH key pair for both sides results in predictable shared + * secrets. + */ + public void insecureKeyExchangeExample() throws Exception { + System.out.println("\n--- Insecure Key Exchange Example ---"); + + // Example 1: Using weak 512-bit DH with static key reuse. + KeyPair staticDHKeyPair = generateDHDeprecated(); + // Reusing the same static DH key pair for both parties. + byte[] staticDHSecret = deriveDHSecret(staticDHKeyPair.getPrivate(), staticDHKeyPair.getPublic()); + System.out.println("Static DH (512-bit) shared secret (reused): " + + Base64.getEncoder().encodeToString(staticDHSecret)); + // SAST Note: 512-bit DH is considered insecure and static key reuse prevents + // forward secrecy. + + // Example 2: Reusing an ECDH key pair instead of generating fresh ephemeral + // keys. + KeyPair reusedECDHKeyPair = generateECDHKeyPair(); + // Using the same key pair for both sides leads to a shared secret that is + // easily derived. + byte[] reusedECDHSecret = deriveECDHSecret(reusedECDHKeyPair.getPrivate(), reusedECDHKeyPair.getPublic()); + System.out.println("Reused ECDH shared secret: " + + Base64.getEncoder().encodeToString(reusedECDHSecret)); + // SAST Note: Proper key exchange requires fresh ephemeral keys for each session + // to ensure forward secrecy. + } + + ////////////////////////////////////////// + // 6. runAllExchanges() Demo Method + ////////////////////////////////////////// + + /** + * Demonstrates key exchange flows for various algorithms, including both secure + * and insecure examples. + * + * CBOM/SAST Classification: + * - Exercises both safe configurations (e.g., DH with 2048/4096-bit, ECDH, + * X25519, X448) + * and insecure configurations (e.g., DH with 512-bit, static key reuse). + */ + public void runAllExchanges() throws Exception { + System.out.println("--- Running Secure Key Exchanges ---"); + + // ============ DEPRECATED / UNSAFE DH (512 bits) ============ + KeyPair dhDep1 = generateDHDeprecated(); + KeyPair dhDep2 = generateDHDeprecated(); + byte[] dhDepSecret1 = deriveDHSecret(dhDep1.getPrivate(), dhDep2.getPublic()); + byte[] dhDepSecret2 = deriveDHSecret(dhDep2.getPrivate(), dhDep1.getPublic()); + System.out.println("DH(512) K1->K2: " + Base64.getEncoder().encodeToString(dhDepSecret1)); + System.out.println("DH(512) K2->K1: " + Base64.getEncoder().encodeToString(dhDepSecret2)); + System.out.println("DH(512) match? " + Arrays.equals(dhDepSecret1, dhDepSecret2)); + + // ============ DH (2048 bits) Standard ============ + KeyPair dhKP1 = generateDHKeyPair(); + KeyPair dhKP2 = generateDHKeyPair(); + byte[] dhSecret1 = deriveDHSecret(dhKP1.getPrivate(), dhKP2.getPublic()); + byte[] dhSecret2 = deriveDHSecret(dhKP2.getPrivate(), dhKP1.getPublic()); + System.out.println("DH(2048) K1->K2: " + Base64.getEncoder().encodeToString(dhSecret1)); + System.out.println("DH(2048) K2->K1: " + Base64.getEncoder().encodeToString(dhSecret2)); + System.out.println("DH(2048) match? " + Arrays.equals(dhSecret1, dhSecret2)); + + // ============ DH (4096 bits) High-Security ============ + KeyPair dhHigh1 = generateDHHighSecurity(); + KeyPair dhHigh2 = generateDHHighSecurity(); + byte[] dhHighSecret1 = deriveDHSecret(dhHigh1.getPrivate(), dhHigh2.getPublic()); + byte[] dhHighSecret2 = deriveDHSecret(dhHigh2.getPrivate(), dhHigh1.getPublic()); + System.out.println("DH(4096) K1->K2: " + Base64.getEncoder().encodeToString(dhHighSecret1)); + System.out.println("DH(4096) K2->K1: " + Base64.getEncoder().encodeToString(dhHighSecret2)); + System.out.println("DH(4096) match? " + Arrays.equals(dhHighSecret1, dhHighSecret2)); + + // ============ ECDH (secp256r1) ============ + KeyPair ecKP1 = generateECDHKeyPair(); + KeyPair ecKP2 = generateECDHKeyPair(); + byte[] ecdhSecret1 = deriveECDHSecret(ecKP1.getPrivate(), ecKP2.getPublic()); + byte[] ecdhSecret2 = deriveECDHSecret(ecKP2.getPrivate(), ecKP1.getPublic()); + System.out.println("ECDH K1->K2: " + Base64.getEncoder().encodeToString(ecdhSecret1)); + System.out.println("ECDH K2->K1: " + Base64.getEncoder().encodeToString(ecdhSecret2)); + System.out.println("ECDH match? " + Arrays.equals(ecdhSecret1, ecdhSecret2)); + + // ============ X25519 ============ + KeyPair x25519KP1 = generateX25519KeyPair(); + KeyPair x25519KP2 = generateX25519KeyPair(); + byte[] x25519Secret1 = deriveX25519Secret(x25519KP1.getPrivate(), x25519KP2.getPublic()); + byte[] x25519Secret2 = deriveX25519Secret(x25519KP2.getPrivate(), x25519KP1.getPublic()); + System.out.println("X25519 K1->K2: " + Base64.getEncoder().encodeToString(x25519Secret1)); + System.out.println("X25519 K2->K1: " + Base64.getEncoder().encodeToString(x25519Secret2)); + System.out.println("X25519 match? " + Arrays.equals(x25519Secret1, x25519Secret2)); + + // ============ X448 ============ + KeyPair x448KP1 = generateX448KeyPair(); + KeyPair x448KP2 = generateX448KeyPair(); + byte[] x448Secret1 = deriveX448Secret(x448KP1.getPrivate(), x448KP2.getPublic()); + byte[] x448Secret2 = deriveX448Secret(x448KP2.getPrivate(), x448KP1.getPublic()); + System.out.println("X448 K1->K2: " + Base64.getEncoder().encodeToString(x448Secret1)); + System.out.println("X448 K2->K1: " + Base64.getEncoder().encodeToString(x448Secret2)); + System.out.println("X448 match? " + Arrays.equals(x448Secret1, x448Secret2)); + + // ============ Insecure Key Exchange Example ============ + insecureKeyExchangeExample(); + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/MACOperation.java b/java/ql/test/experimental/library-tests/quantum/jca/MACOperation.java new file mode 100644 index 000000000000..ae55b52bcfc3 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/MACOperation.java @@ -0,0 +1,249 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.SecretKeyFactory; +import javax.crypto.spec.PBEKeySpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * MACOperation demonstrates various Message Authentication Code (MAC) + * operations and further use of MAC outputs as inputs into higher-level + * cryptosystems. + * + * Flows include: + * + * 1. Secure HMAC-SHA2 (HMAC-SHA256) - a widely accepted MAC. 2. Secure + * HMAC-SHA3 (HMAC-SHA3-256) - an alternative using the SHA-3 family. 3. Secure + * Poly1305 MAC - using BouncyCastle's implementation. 4. Secure GMAC - using + * AES-GCM's authentication tag in a dedicated MAC mode. 5. Secure KMAC - using + * KMAC128 (from the SHA-3 family). + * + * Insecure examples include: + * + * 6. Insecure HMAC-SHA1 - which is deprecated. + * + * Further flows: + * + * A. processMACOutput: Uses the MAC output directly as key material for AES + * encryption. (Note: This is acceptable only if the MAC is produced by a secure + * function.) + * + * B. alternativeMACFlow: Uses the MAC output as an identifier that is then + * encrypted. + * + * C. furtherUseMACForKeyDerivation: Uses PBKDF2 to split a MAC output into two + * keys, one for encryption and one for MACing ciphertext. + * + * SAST/CBOM Notes: - Secure MAC algorithms (HMAC-SHA256, HMAC-SHA3-256, + * Poly1305, GMAC, KMAC128) are acceptable if used correctly. - HMAC-SHA1 is + * flagged as insecure. - Using a raw MAC output directly as key material is + * ambiguous unless the MAC is produced by a secure KDF. + */ +public class MACOperation { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + // ---------- MAC Operations ---------- + /** + * Secure MAC using HMAC-SHA256. SAST: HMAC-SHA256 is widely considered + * secure. + */ + public byte[] secureHMACSHA256(String message, byte[] key) throws Exception { + Mac mac = Mac.getInstance("HmacSHA256", "BC"); + SecretKey secretKey = new SecretKeySpec(key, "HmacSHA256"); + mac.init(secretKey); + return mac.doFinal(message.getBytes()); + } + + /** + * Secure MAC using HMAC-SHA3-256. SAST: HMAC-SHA3 is a modern alternative + * from the SHA-3 family. + */ + public byte[] secureHMACSHA3(String message, byte[] key) throws Exception { + Mac mac = Mac.getInstance("HmacSHA3-256", "BC"); + SecretKey secretKey = new SecretKeySpec(key, "HmacSHA3-256"); + mac.init(secretKey); + return mac.doFinal(message.getBytes()); + } + + /** + * Secure MAC using Poly1305. SAST: Poly1305 is secure when used with a + * one-time key from a cipher (e.g. ChaCha20). + */ + public byte[] securePoly1305(String message, byte[] key) throws Exception { + Mac mac = Mac.getInstance("Poly1305", "BC"); + SecretKey secretKey = new SecretKeySpec(key, "Poly1305"); + mac.init(secretKey); + return mac.doFinal(message.getBytes()); + } + + /** + * Secure MAC using GMAC. SAST: GMAC (the MAC part of AES-GCM) is secure + * when used correctly. + */ + public byte[] secureGMAC(String message, byte[] key) throws Exception { + // For GMAC, we use the GMac algorithm as provided by BC. + Mac mac = Mac.getInstance("GMac", "BC"); + // Initialize the key for GMAC; key should be appropriate for the underlying + // block cipher. + SecretKey secretKey = new SecretKeySpec(key, "AES"); + mac.init(secretKey); + return mac.doFinal(message.getBytes()); + } + + /** + * Secure MAC using KMAC128. SAST: KMAC128 is part of the SHA-3 family and + * is secure when used properly. + */ + public byte[] secureKMAC(String message, byte[] key) throws Exception { + Mac mac = Mac.getInstance("KMAC128", "BC"); + SecretKey secretKey = new SecretKeySpec(key, "KMAC128"); + mac.init(secretKey); + return mac.doFinal(message.getBytes()); + } + + /** + * Insecure MAC using HMAC-SHA1. SAST: HMAC-SHA1 is considered deprecated + * and weak. + */ + public byte[] insecureHMACSHA1(String message, byte[] key) throws Exception { + Mac mac = Mac.getInstance("HmacSHA1", "BC"); + SecretKey secretKey = new SecretKeySpec(key, "HmacSHA1"); + mac.init(secretKey); + return mac.doFinal(message.getBytes()); + } + + // ---------- Further Use of MAC Outputs ---------- + /** + * Processes the MAC output by using it as key material for AES encryption. + * SAST: Using a raw MAC output as key material is acceptable only if the + * MAC was produced by a secure function; otherwise, this is ambiguous. + * + * @param macOutput The computed MAC output. + * @throws Exception if encryption fails. + */ + public void processMACOutput(byte[] macOutput) throws Exception { + // Derive a 128-bit AES key from the MAC output. + SecretKey key = new SecretKeySpec(macOutput, 0, 16, "AES"); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, key, new SecureRandom()); + byte[] encryptedData = cipher.doFinal("Sensitive Data".getBytes()); + storeEncryptedMAC(encryptedData); + } + + /** + * Alternative flow: Uses the MAC output as an identifier and then encrypts + * it. SAST: Using a MAC as an identifier is common; subsequent encryption + * must be secure. + * + * @param macOutput The computed MAC output. + * @throws Exception if encryption fails. + */ + public void alternativeMACFlow(byte[] macOutput) throws Exception { + byte[] identifier = Base64.getEncoder().encode(macOutput); + encryptAndSend(identifier); + } + + /** + * Further use: Derives two separate keys from the MAC output using PBKDF2, + * then uses one key for encryption and one for computing an additional MAC + * over the ciphertext. + * + * SAST: This key-splitting technique is acceptable if PBKDF2 is used + * securely. + * + * @param macOutput The MAC output to derive keys from. + * @throws Exception if key derivation or encryption fails. + */ + public void furtherUseMACForKeyDerivation(byte[] macOutput) throws Exception { + // Use the Base64 representation of the MAC as the password input to PBKDF2. + String macAsPassword = Base64.getEncoder().encodeToString(macOutput); + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(macAsPassword.toCharArray(), salt, 10000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] keyMaterial = factory.generateSecret(spec).getEncoded(); + // Split into two 128-bit keys. + byte[] encryptionKeyBytes = Arrays.copyOfRange(keyMaterial, 0, 16); + byte[] macKeyBytes = Arrays.copyOfRange(keyMaterial, 16, 32); + SecretKey encryptionKey = new SecretKeySpec(encryptionKeyBytes, "AES"); + SecretKey derivedMacKey = new SecretKeySpec(macKeyBytes, "HmacSHA256"); + + // Encrypt some sample data using the derived encryption key. + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, encryptionKey, new SecureRandom()); + byte[] ciphertext = cipher.doFinal("Further Use Test Data".getBytes()); + + // Compute HMAC over the ciphertext using the derived MAC key. + Mac mac = Mac.getInstance("HmacSHA256"); + mac.init(derivedMacKey); + byte[] computedMac = mac.doFinal(ciphertext); + + // Concatenate the ciphertext and MAC for further use. + byte[] output = new byte[ciphertext.length + computedMac.length]; + System.arraycopy(ciphertext, 0, output, 0, ciphertext.length); + System.arraycopy(computedMac, 0, output, ciphertext.length, computedMac.length); + storeEncryptedMAC(output); + } + + // ---------- Output/Storage Methods ---------- + /** + * Simulates secure storage or transmission of an encrypted MAC output. + * SAST: In production, storage and transmission must be protected. + * + * @param encryptedMAC The encrypted MAC output. + */ + public void storeEncryptedMAC(byte[] encryptedMAC) { + String stored = Base64.getEncoder().encodeToString(encryptedMAC); + // In production, this string would be securely stored or transmitted. + } + + /** + * Encrypts data using AES-GCM and simulates secure transmission. SAST: Uses + * a securely generated AES key. + * + * @param data The data to encrypt. + * @throws Exception if encryption fails. + */ + public void encryptAndSend(byte[] data) throws Exception { + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + SecretKey key = generateAESKey(); + cipher.init(Cipher.ENCRYPT_MODE, key, new SecureRandom()); + byte[] encryptedData = cipher.doFinal(data); + storeEncryptedMAC(encryptedData); + } + + // ---------- Helper Methods ---------- + /** + * Generates a secure 256-bit AES key. SAST: Uses a strong RNG for key + * generation. + * + * @return A SecretKey for AES. + * @throws NoSuchAlgorithmException if AES is unsupported. + */ + private SecretKey generateAESKey() throws NoSuchAlgorithmException { + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256); + return keyGen.generateKey(); + } + + /** + * Generates a random salt of the specified length using SecureRandom. SAST: + * Salting is essential for secure key derivation. + * + * @param length The salt length. + * @return A byte array representing the salt. + */ + private byte[] generateSalt(int length) { + byte[] salt = new byte[length]; + new SecureRandom().nextBytes(salt); + return salt; + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/Nonce.java b/java/ql/test/experimental/library-tests/quantum/jca/Nonce.java new file mode 100644 index 000000000000..c99113d7a016 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/Nonce.java @@ -0,0 +1,114 @@ +package com.example.crypto.artifacts; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import javax.crypto.KeyGenerator; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.Cipher; +import java.security.*; +import java.util.Base64; +import java.util.Random; + +public class Nonce { + + // static { + // Security.addProvider(new BouncyCastleProvider()); // Ensure BouncyCastle is available + // } + /** + * Simple Case: Generates a secure nonce and uses it in HMAC. + */ + public void simpleNonceUsage() throws Exception { + byte[] nonce = secureNonce(16); + SecretKey key = generateHmacKey(); + Mac mac = Mac.getInstance("HmacSHA256"); + mac.init(key); + mac.update(nonce); + byte[] macResult = mac.doFinal("Simple Test Data".getBytes()); + } + + /** + * Incorrect: Hardcoded, reused nonce in encryption, leading to predictable + * output. + */ + public void hardcodedNonceReuse() throws Exception { + byte[] nonce = "BADNONCEBADNONCE".getBytes(); // HARDCODED NONCE REUSED! + SecretKey key = generateHmacKey(); + Mac mac = Mac.getInstance("HmacSHA256"); + mac.init(key); + mac.update(nonce); + byte[] macResult = mac.doFinal("Sensitive Data".getBytes()); + } + + /** + * Incorrect: Reusing a nonce with AES-GCM, which can lead to catastrophic + * security failures. + */ + public void insecureNonceReuseGCM(SecretKey key, byte[] plaintext) throws Exception { + byte[] nonce = getReusedNonce(12); // SAME NONCE REUSED! + GCMParameterSpec gcmSpec = new GCMParameterSpec(128, nonce); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, key, gcmSpec); + byte[] ciphertext = cipher.doFinal(plaintext); + } + + /** + * Secure Case: Proper unique nonce usage in AES-GCM. + */ + public void secureNonceUsageGCM(SecretKey key, byte[] plaintext) throws Exception { + byte[] nonce = secureNonce(12); + GCMParameterSpec gcmSpec = new GCMParameterSpec(128, nonce); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + cipher.init(Cipher.ENCRYPT_MODE, key, gcmSpec); + byte[] ciphertext = cipher.doFinal(plaintext); + } + + public void complexNonceFlow() { + byte[] nonce = useSecureMethod() ? secureNonce(16) : insecureNonce(16); + processNonce(nonce); + try { + useNonceInMac(nonce, generateHmacKey(), "HmacSHA256"); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public void useNonceInMac(byte[] nonce, SecretKey key, String macAlgorithm) throws Exception { + Mac mac = Mac.getInstance(macAlgorithm); + mac.init(key); + mac.update(nonce); + byte[] macResult = mac.doFinal("Sensitive Data".getBytes()); + } + + private boolean useSecureMethod() { + return System.currentTimeMillis() % 2 == 0; + } + + private void processNonce(byte[] nonce) { + String nonceBase64 = Base64.getEncoder().encodeToString(nonce); + } + + private SecretKey generateHmacKey() throws NoSuchAlgorithmException { + KeyGenerator keyGen = KeyGenerator.getInstance("HmacSHA256"); + return keyGen.generateKey(); + } + + private byte[] secureNonce(int length) { + byte[] nonce = new byte[length]; + new SecureRandom().nextBytes(nonce); + return nonce; + } + + private byte[] insecureNonce(int length) { + byte[] nonce = new byte[length]; + new Random().nextBytes(nonce); + return nonce; + } + + /** + * Incorrect: A nonce that is stored and reused across multiple encryptions. + */ + private byte[] getReusedNonce(int length) { + return "BADNONCEBADNONCE".getBytes(); // Fixed nonce reuse across calls + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/PrngTest.java b/java/ql/test/experimental/library-tests/quantum/jca/PrngTest.java new file mode 100644 index 000000000000..313c4fd4e872 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/PrngTest.java @@ -0,0 +1,156 @@ +package com.example.crypto.algorithms; + +import java.security.NoSuchAlgorithmException; +import java.security.SecureRandom; +import java.util.Random; +import javax.crypto.SecretKey; +import javax.crypto.KeyGenerator; + +/** + * PrngTest demonstrates various approaches for generating random data using + * PRNG/RNG APIs. + * + * It covers: 1) Secure random generation using SecureRandom (default and + * getInstanceStrong). 2) Insecure random generation using java.util.Random. 3) + * Flawed PRNG usage by setting a fixed seed. 4) Dynamic PRNG selection based on + * configuration. 5) Usage of random data as nonces/IVs in symmetric encryption. + * + * SAST/CBOM Notes: - SecureRandom (and SecureRandom.getInstanceStrong) are + * recommended. - java.util.Random is not suitable for cryptographic purposes. - + * Re-seeding or using a fixed seed with SecureRandom makes it predictable. - + * IVs and nonces must be unique for each operation; reusing fixed values is + * insecure. + */ +public class PrngTest { + + // ---------- Secure Random Generation ---------- + /** + * Generates random bytes using the default SecureRandom. SAST: SecureRandom + * is recommended for cryptographically secure random data. + * + * @param numBytes Number of bytes to generate. + * @return A byte array of random data. + */ + public byte[] generateSecureRandomBytes(int numBytes) { + SecureRandom secureRandom = new SecureRandom(); + byte[] bytes = new byte[numBytes]; + secureRandom.nextBytes(bytes); + return bytes; + } + + /** + * Generates random bytes using SecureRandom.getInstanceStrong(). SAST: + * getInstanceStrong() returns a strong RNG (may block in some + * environments). + * + * @param numBytes Number of bytes to generate. + * @return A byte array of random data. + * @throws NoSuchAlgorithmException if a strong RNG is not available. + */ + public byte[] generateSecureRandomBytesStrong(int numBytes) throws NoSuchAlgorithmException { + SecureRandom secureRandom = SecureRandom.getInstanceStrong(); + byte[] bytes = new byte[numBytes]; + secureRandom.nextBytes(bytes); + return bytes; + } + + // ---------- Insecure Random Generation ---------- + /** + * Generates random bytes using java.util.Random. SAST: java.util.Random is + * predictable and insecure for cryptographic purposes. + * + * @param numBytes Number of bytes to generate. + * @return A byte array of random data. + */ + public byte[] generateInsecureRandomBytes(int numBytes) { + Random random = new Random(); + byte[] bytes = new byte[numBytes]; + random.nextBytes(bytes); + return bytes; + } + + /** + * Generates random bytes using SecureRandom with a fixed seed. SAST: Fixed + * seeding makes SecureRandom predictable and insecure. + * + * @param numBytes Number of bytes to generate. + * @return A byte array of predictable random data. + */ + public byte[] generatePredictableRandomBytes(int numBytes) { + SecureRandom secureRandom = new SecureRandom(); + // Fixed seed (predictable and insecure) + secureRandom.setSeed(0xDEADBEEF); + byte[] bytes = new byte[numBytes]; + secureRandom.nextBytes(bytes); + return bytes; + } + + // ---------- Dynamic PRNG Selection ---------- + /** + * Dynamically selects a PRNG algorithm based on a configuration property. + * If the algorithm is unknown, falls back to java.util.Random (insecure). + * SAST: Dynamic selection may introduce risk if an insecure RNG is chosen. + * + * @param algorithmName The PRNG algorithm name (e.g. "SHA1PRNG", + * "NativePRNGNonBlocking", "getInstanceStrong"). + * @param numBytes Number of bytes to generate. + * @return A byte array of random data. + * @throws NoSuchAlgorithmException if the algorithm is not available. + */ + public byte[] dynamicRandomGeneration(String algorithmName, int numBytes) throws NoSuchAlgorithmException { + SecureRandom secureRandom; + if ("SHA1PRNG".equalsIgnoreCase(algorithmName)) { + // SHA1PRNG is older and less preferred. + secureRandom = SecureRandom.getInstance("SHA1PRNG"); + } else if ("NativePRNGNonBlocking".equalsIgnoreCase(algorithmName)) { + secureRandom = SecureRandom.getInstance("NativePRNGNonBlocking"); + } else if ("getInstanceStrong".equalsIgnoreCase(algorithmName)) { + secureRandom = SecureRandom.getInstanceStrong(); + } else { + // Fallback to insecure java.util.Random. + Random random = new Random(); + byte[] bytes = new byte[numBytes]; + random.nextBytes(bytes); + return bytes; + } + byte[] bytes = new byte[numBytes]; + secureRandom.nextBytes(bytes); + return bytes; + } + + // ---------- Usage Examples: Nonce/IV Generation for Symmetric Encryption + // ---------- + /** + * Demonstrates secure generation of an IV for AES-GCM encryption. SAST: A + * unique, random IV is required for each encryption operation. + * + * @return A 12-byte IV. + */ + public byte[] generateRandomIVForGCM() { + return generateSecureRandomBytes(12); + } + + /** + * Demonstrates insecure use of a fixed IV for AES-GCM encryption. SAST: + * Reusing a fixed IV in AES-GCM compromises security. + * + * @return A fixed 12-byte IV (all zeros). + */ + public byte[] generateFixedIVForGCM() { + return new byte[12]; // 12 bytes of zeros. + } + + // ---------- Example: Using PRNG for Key Generation ---------- + /** + * Generates a secure 256-bit AES key using SecureRandom. SAST: Strong key + * generation is critical for symmetric cryptography. + * + * @return A new AES SecretKey. + * @throws Exception if key generation fails. + */ + public SecretKey generateAESKey() throws Exception { + KeyGenerator keyGen = KeyGenerator.getInstance("AES"); + keyGen.init(256, new SecureRandom()); + return keyGen.generateKey(); + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/SignEncryptCombinations.java b/java/ql/test/experimental/library-tests/quantum/jca/SignEncryptCombinations.java new file mode 100644 index 000000000000..d238aab173c7 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/SignEncryptCombinations.java @@ -0,0 +1,359 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; +import java.security.spec.ECGenParameterSpec; +import java.util.Arrays; +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; + +/** + * This class demonstrates cryptographic flows combining signing, encryption, + * and MAC. + * + * It intentionally includes both safe and unsafe patterns so that a SAST tool + * can detect: + * + * 1. **Sign then Encrypt (Unsafe)** - Signs the plaintext and encrypts only the + * signature, leaving the plaintext in cleartext. - *Issue:* The message is + * exposed, which could lead to replay or modification attacks. + * + * 2. **Encrypt then Sign (Safe with caveats)** - Encrypts the plaintext and + * then signs the ciphertext. - *Caveat:* The signature is in the clear; + * metadata (e.g. ciphertext length) may be exposed. + * + * 3. **MAC then Encrypt (Unsafe)** - Computes a MAC on the plaintext and + * appends it before encryption. - *Issue:* Operating on plaintext for MAC + * generation can leak information and is discouraged. + * + * 4. **Encrypt then MAC (Safe)** - Encrypts the plaintext and computes a MAC + * over the ciphertext. - *Benefit:* Provides a robust authenticated encryption + * construction when not using an AEAD cipher. + * + * Note: AES/GCM already provides authentication, so adding an external MAC is + * redundant. + */ +public class SignEncryptCombinations { + + private static final SecureRandom RANDOM = new SecureRandom(); + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + /////////////////////////////////////////////// + // Key Generation for ECDSA on secp256r1 + /////////////////////////////////////////////// + + public KeyPair generateECDSAKeyPair() throws Exception { + KeyPairGenerator ecKpg = KeyPairGenerator.getInstance("EC", "BC"); + ecKpg.initialize(new ECGenParameterSpec("secp256r1"), RANDOM); + return ecKpg.generateKeyPair(); + } + + /////////////////////////////////////////////// + // Signing with ECDSA (SHA256withECDSA) + /////////////////////////////////////////////// + + public byte[] signECDSA(PrivateKey privKey, byte[] data) throws Exception { + Signature signature = Signature.getInstance("SHA256withECDSA", "BC"); + signature.initSign(privKey, RANDOM); + signature.update(data); + return signature.sign(); + } + + public boolean verifyECDSA(PublicKey pubKey, byte[] data, byte[] signatureBytes) throws Exception { + Signature signature = Signature.getInstance("SHA256withECDSA", "BC"); + signature.initVerify(pubKey); + signature.update(data); + return signature.verify(signatureBytes); + } + + /////////////////////////////////////////////// + // Symmetric Encryption with AES-GCM + /////////////////////////////////////////////// + + /** + * Generates a 256-bit AES key. + */ + public SecretKey generateAESKey() throws Exception { + KeyGenerator kg = KeyGenerator.getInstance("AES"); + kg.init(256); + return kg.generateKey(); + } + + /** + * Encrypts data using AES-GCM with a 12-byte IV and a 128-bit tag. Returns + * the concatenation of IV and ciphertext. + */ + public byte[] encryptAESGCM(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; // 12-byte IV recommended for GCM + RANDOM.nextBytes(iv); + GCMParameterSpec spec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.ENCRYPT_MODE, key, spec); + byte[] ciphertext = cipher.doFinal(plaintext); + + byte[] result = new byte[iv.length + ciphertext.length]; + System.arraycopy(iv, 0, result, 0, iv.length); + System.arraycopy(ciphertext, 0, result, iv.length, ciphertext.length); + return result; + } + + /** + * Decrypts data that was encrypted using encryptAESGCM. + */ + public byte[] decryptAESGCM(SecretKey key, byte[] ivCiphertext) throws Exception { + byte[] iv = Arrays.copyOfRange(ivCiphertext, 0, 12); + byte[] ciphertext = Arrays.copyOfRange(ivCiphertext, 12, ivCiphertext.length); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + cipher.init(Cipher.DECRYPT_MODE, key, new GCMParameterSpec(128, iv)); + return cipher.doFinal(ciphertext); + } + + /////////////////////////////////////////////// + // HMAC Usage with HMAC-SHA256 + /////////////////////////////////////////////// + + public byte[] computeHmacSHA256(SecretKey key, byte[] data) throws Exception { + Mac mac = Mac.getInstance("HmacSHA256"); + mac.init(key); + return mac.doFinal(data); + } + + public boolean verifyHmacSHA256(SecretKey key, byte[] data, byte[] givenMac) throws Exception { + byte[] computed = computeHmacSHA256(key, data); + return Arrays.equals(computed, givenMac); + } + + /////////////////////////////////////////////// + // 1) SIGN THEN ENCRYPT vs. ENCRYPT THEN SIGN + /////////////////////////////////////////////// + + /** + * UNSAFE FLOW: Signs the plaintext and encrypts only the signature. + * + *

+ * **Issue:** The plaintext message is not encrypted, only the signature is. + * This exposes the original message to eavesdroppers and negates the purpose of + * encryption. + *

+ * + * @param signingKey ECDSA private key for signing. + * @param encryptionKey AES key for encryption. + * @param data The plaintext message. + * @return The encrypted signature only. + */ + public byte[] signThenEncrypt(PrivateKey signingKey, SecretKey encryptionKey, byte[] data) throws Exception { + // Sign the plaintext message. + byte[] signature = signECDSA(signingKey, data); + // **** UNSAFE: Only the signature is encrypted. The plaintext remains in the + // clear. **** + return encryptAESGCM(encryptionKey, signature); + } + + /** + * Decrypts the signature and verifies it against the original plaintext. + */ + public boolean decryptThenVerify(SecretKey encryptionKey, PublicKey verifyingKey, byte[] encryptedSig, + byte[] originalData) throws Exception { + byte[] decryptedSig = decryptAESGCM(encryptionKey, encryptedSig); + return verifyECDSA(verifyingKey, originalData, decryptedSig); + } + + /** + * SAFE FLOW (with caveats): Encrypts the plaintext and then signs the + * ciphertext. + * + *

+ * **Benefit:** The plaintext is fully encrypted and remains confidential. + * **Caveat:** The signature is transmitted in the clear. Although this does + * not compromise the message, it might reveal metadata (like ciphertext + * length). + *

+ * + * @param encryptionKey AES key for encryption. + * @param signingKey ECDSA private key for signing. + * @param data The plaintext message. + * @return The concatenation of the ciphertext and its signature. + */ + public byte[] encryptThenSign(SecretKey encryptionKey, PrivateKey signingKey, byte[] data) throws Exception { + // Encrypt the plaintext. + byte[] ivCiphertext = encryptAESGCM(encryptionKey, data); + // Sign the ciphertext. + byte[] signature = signECDSA(signingKey, ivCiphertext); + + // Combine ciphertext and signature. + byte[] combined = new byte[ivCiphertext.length + signature.length]; + System.arraycopy(ivCiphertext, 0, combined, 0, ivCiphertext.length); + System.arraycopy(signature, 0, combined, ivCiphertext.length, signature.length); + return combined; + } + + /** + * Extracts and verifies the signature from the combined + * ciphertext-signature bundle, then decrypts the ciphertext. + * + *

+ * **Issue:** Here we assume a fixed signature length (70 bytes). In + * production, the signature length should be explicitly stored. Hard-coding + * a length is an unsafe pattern and may trigger SAST warnings. + *

+ * + * @param verifyingKey ECDSA public key for signature verification. + * @param encryptionKey AES key for decryption. + * @param combined The combined ciphertext and signature. + * @return The decrypted plaintext message. + */ + public byte[] verifyThenDecrypt(PublicKey verifyingKey, SecretKey encryptionKey, byte[] combined) throws Exception { + int assumedSignatureLength = 70; // UNSAFE: Hard-coded signature length. + if (combined.length < assumedSignatureLength) { + throw new IllegalArgumentException("Combined data too short."); + } + int ctLen = combined.length - assumedSignatureLength; + byte[] ivCiphertext = Arrays.copyOfRange(combined, 0, ctLen); + byte[] signature = Arrays.copyOfRange(combined, ctLen, combined.length); + + if (!verifyECDSA(verifyingKey, ivCiphertext, signature)) { + throw new SecurityException("Signature verification failed."); + } + return decryptAESGCM(encryptionKey, ivCiphertext); + } + + /////////////////////////////////////////////// + // 2) MAC THEN ENCRYPT vs. ENCRYPT THEN MAC + /////////////////////////////////////////////// + + /** + * UNSAFE FLOW: Computes a MAC on the plaintext, appends it to the plaintext, + * and then encrypts the combined data. + * + *

+ * **Issue:** Operating on unencrypted plaintext to compute the MAC can leak + * structural + * information. Additionally, if the encryption scheme does not provide + * integrity, + * this construction is vulnerable. + *

+ * + * @param macKey AES key used as the HMAC key (should be separate from the + * encryption key). + * @param encKey AES key for encryption. + * @param data The plaintext message. + * @return The encrypted (plaintext + MAC) bundle. + */ + public byte[] macThenEncrypt(SecretKey macKey, SecretKey encKey, byte[] data) throws Exception { + // Compute MAC over the plaintext. + byte[] mac = computeHmacSHA256(macKey, data); + // Combine plaintext and MAC. + byte[] combined = new byte[data.length + mac.length]; + System.arraycopy(data, 0, combined, 0, data.length); + System.arraycopy(mac, 0, combined, data.length, mac.length); + // **** UNSAFE: The MAC is computed on plaintext, which can leak information. + // **** + return encryptAESGCM(encKey, combined); + } + + /** + * Decrypts the combined data and verifies the MAC. + * + * @param macKey AES key used as the HMAC key. + * @param encKey AES key for decryption. + * @param ciphertext The encrypted bundle containing plaintext and MAC. + * @return true if the MAC is valid; false otherwise. + */ + public boolean decryptThenVerifyMac(SecretKey macKey, SecretKey encKey, byte[] ciphertext) throws Exception { + byte[] combined = decryptAESGCM(encKey, ciphertext); + if (combined.length < 32) { // HMAC-SHA256 produces a 32-byte MAC. + throw new IllegalArgumentException("Combined data too short for MAC verification."); + } + int dataLen = combined.length - 32; + byte[] originalData = Arrays.copyOfRange(combined, 0, dataLen); + byte[] extractedMac = Arrays.copyOfRange(combined, dataLen, combined.length); + return verifyHmacSHA256(macKey, originalData, extractedMac); + } + + /** + * SAFE FLOW: Encrypts the plaintext and then computes a MAC over the + * ciphertext. + * + *

+ * **Benefit:** This "encrypt-then-MAC" construction ensures that the + * ciphertext is both confidential and tamper-evident. + *

+ * + * @param encKey AES key for encryption. + * @param macKey AES key used as the HMAC key. + * @param data The plaintext message. + * @return The concatenation of ciphertext and MAC. + */ + public byte[] encryptThenMac(SecretKey encKey, SecretKey macKey, byte[] data) throws Exception { + // Encrypt the plaintext. + byte[] ivCiphertext = encryptAESGCM(encKey, data); + // Compute MAC over the ciphertext. + byte[] mac = computeHmacSHA256(macKey, ivCiphertext); + // Combine ciphertext and MAC. + byte[] combined = new byte[ivCiphertext.length + mac.length]; + System.arraycopy(ivCiphertext, 0, combined, 0, ivCiphertext.length); + System.arraycopy(mac, 0, combined, ivCiphertext.length, mac.length); + return combined; + } + + /** + * Verifies the MAC and then decrypts the ciphertext. + * + * @param encKey AES key for decryption. + * @param macKey AES key used as the HMAC key. + * @param combined The combined ciphertext and MAC. + * @return The decrypted plaintext message. + */ + public byte[] verifyMacThenDecrypt(SecretKey encKey, SecretKey macKey, byte[] combined) throws Exception { + if (combined.length < 32) { + throw new IllegalArgumentException("Combined data too short for MAC verification."); + } + int macOffset = combined.length - 32; + byte[] ivCiphertext = Arrays.copyOfRange(combined, 0, macOffset); + byte[] extractedMac = Arrays.copyOfRange(combined, macOffset, combined.length); + if (!verifyHmacSHA256(macKey, ivCiphertext, extractedMac)) { + throw new SecurityException("MAC verification failed."); + } + return decryptAESGCM(encKey, ivCiphertext); + } + + /////////////////////////////////////////////// + // Demo: runAllCombinations + /////////////////////////////////////////////// + + public void runAllCombinations() throws Exception { + // Generate keys for signing and for encryption/MAC. + KeyPair signingKeys = generateECDSAKeyPair(); + SecretKey encKey = generateAESKey(); + SecretKey macKey = generateAESKey(); // Ensure a separate key for MAC operations. + + byte[] message = "Hello, combinations!".getBytes(); + + // 1) Sign then Encrypt (Unsafe) vs. Encrypt then Sign (Safe with caveats) + System.out.println("--Sign Then Encrypt (UNSAFE)"); + byte[] encryptedSig = signThenEncrypt(signingKeys.getPrivate(), encKey, message); + boolean steVerified = decryptThenVerify(encKey, signingKeys.getPublic(), encryptedSig, message); + System.out.println("signThenEncrypt -> signature verified? " + steVerified); + + System.out.println("--Encrypt Then Sign (SAFE with caveats)"); + byte[] combinedETS = encryptThenSign(encKey, signingKeys.getPrivate(), message); + byte[] finalPlain = verifyThenDecrypt(signingKeys.getPublic(), encKey, combinedETS); + System.out.println("encryptThenSign -> decrypted message: " + new String(finalPlain)); + + // 2) MAC then Encrypt (Unsafe) vs. Encrypt then MAC (Safe) + System.out.println("--MAC Then Encrypt (UNSAFE)"); + byte[] mteCipher = macThenEncrypt(macKey, encKey, message); + boolean mteVerified = decryptThenVerifyMac(macKey, encKey, mteCipher); + System.out.println("macThenEncrypt -> MAC verified? " + mteVerified); + + System.out.println("--Encrypt Then MAC (SAFE)"); + byte[] etmCombined = encryptThenMac(encKey, macKey, message); + byte[] etmPlain = verifyMacThenDecrypt(encKey, macKey, etmCombined); + System.out.println("encryptThenMac -> decrypted message: " + new String(etmPlain)); + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/SignatureOperation.java b/java/ql/test/experimental/library-tests/quantum/jca/SignatureOperation.java new file mode 100644 index 000000000000..2efba7c5c770 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/SignatureOperation.java @@ -0,0 +1,346 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; +import java.security.spec.ECGenParameterSpec; +import java.util.Base64; +import java.util.Properties; + +/** + * Demonstrates various digital signature operations: + * + * 1) RSA-PSS (modern, safer) - CBOM/SAST: Classified as a Modern Digital + * Signature scheme using RSA-PSS. RSA-PSS with SHA-256 is recommended. + * + * 2) ECDSA with secp256r1 - CBOM/SAST: Classified as an Elliptic Curve Digital + * Signature Algorithm. Secure when used with a strong curve and proper + * randomness. + * + * 3) Ed25519 (RFC 8032) - CBOM/SAST: Classified as a modern, high-performance + * signature scheme. + * + * 4) SHA1withRSA (deprecated/unsafe example) - CBOM/SAST: Classified as a + * legacy digital signature scheme. SHA-1 and 1024-bit RSA are deprecated. + * + * Additional nuanced examples: + * + * - Signing and verifying an empty message. - Signing data with non-ASCII + * characters. - Demonstrating signature tampering and its detection. - A + * dynamic (runtime-selected) signature algorithm scenario ("known unknown"). + * + * Requirements: - BouncyCastle for ECDSA, Ed25519, and RSA-PSS (if needed). - + * Java 11+ for native Ed25519 support or using BC for older versions. + */ +public class SignatureOperation { + + // static { + // // Register the BouncyCastle provider. + // Security.addProvider(new BouncyCastleProvider()); + // } + /////////////////////////////////////// + // 1. RSA-PSS (Recommended) + /////////////////////////////////////// + + /** + * Generate an RSA key pair for RSA-PSS. + * Uses a 2048-bit key. + * + * CBOM/SAST Notes: + * - Parent: Modern Digital Signature (RSA-PSS). + */ + public KeyPair generateRSAPSSKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); + kpg.initialize(2048); + return kpg.generateKeyPair(); + } + + /** + * Sign data using RSA-PSS with SHA-256. + * + * CBOM/SAST Notes: - Parent: Modern Digital Signature (RSA-PSS). + */ + public byte[] signRSAPSS(PrivateKey privateKey, byte[] data) throws Exception { + Signature signature = Signature.getInstance("SHA256withRSAandMGF1"); + signature.initSign(privateKey); + signature.update(data); + return signature.sign(); + } + + /** + * Verify data using RSA-PSS with SHA-256. + * + * CBOM/SAST Notes: - Parent: Modern Digital Signature (RSA-PSS). + */ + public boolean verifyRSAPSS(PublicKey publicKey, byte[] data, byte[] sigBytes) throws Exception { + Signature signature = Signature.getInstance("SHA256withRSAandMGF1"); + signature.initVerify(publicKey); + signature.update(data); + return signature.verify(sigBytes); + } + + /////////////////////////////////////// + // 2. ECDSA (secp256r1) + /////////////////////////////////////// + + /** + * Generate an ECDSA key pair on secp256r1. + * + * CBOM/SAST Notes: + * - Parent: Elliptic Curve Digital Signature. + */ + public KeyPair generateECDSAKeyPair() throws Exception { + KeyPairGenerator ecKpg = KeyPairGenerator.getInstance("EC", "BC"); + ecKpg.initialize(new ECGenParameterSpec("secp256r1"), new SecureRandom()); + return ecKpg.generateKeyPair(); + } + + /** + * Sign data using ECDSA with SHA-256. + * + * CBOM/SAST Notes: - Parent: Elliptic Curve Digital Signature. + */ + public byte[] signECDSA(PrivateKey privateKey, byte[] data) throws Exception { + Signature signature = Signature.getInstance("SHA256withECDSA", "BC"); + signature.initSign(privateKey); + signature.update(data); + return signature.sign(); + } + + /** + * Verify data using ECDSA with SHA-256. + * + * CBOM/SAST Notes: - Parent: Elliptic Curve Digital Signature. + */ + public boolean verifyECDSA(PublicKey publicKey, byte[] data, byte[] sigBytes) throws Exception { + Signature signature = Signature.getInstance("SHA256withECDSA", "BC"); + signature.initVerify(publicKey); + signature.update(data); + return signature.verify(sigBytes); + } + + /////////////////////////////////////// + // 3. Ed25519 (RFC 8032) + /////////////////////////////////////// + + /** + * Generate an Ed25519 key pair. + * + * CBOM/SAST Notes: + * - Parent: Modern Digital Signature (EdDSA). + */ + public KeyPair generateEd25519KeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("Ed25519", "BC"); + return kpg.generateKeyPair(); + } + + /** + * Sign data using Ed25519. + * + * CBOM/SAST Notes: - Parent: Modern Digital Signature (EdDSA). + */ + public byte[] signEd25519(PrivateKey privateKey, byte[] data) throws Exception { + Signature signature = Signature.getInstance("Ed25519", "BC"); + signature.initSign(privateKey); + signature.update(data); + return signature.sign(); + } + + /** + * Verify data using Ed25519. + * + * CBOM/SAST Notes: - Parent: Modern Digital Signature (EdDSA). + */ + public boolean verifyEd25519(PublicKey publicKey, byte[] data, byte[] sigBytes) throws Exception { + Signature signature = Signature.getInstance("Ed25519", "BC"); + signature.initVerify(publicKey); + signature.update(data); + return signature.verify(sigBytes); + } + + /////////////////////////////////////// + // 4. SHA1withRSA (Deprecated/Unsafe) + /////////////////////////////////////// + + /** + * Generate an RSA key pair for the deprecated/unsafe example. + * Uses a 1024-bit key. + * + * CBOM/SAST Notes: + * - Parent: Legacy Digital Signature. + * - RSA with SHA-1 and 1024-bit keys is deprecated and should be avoided. + */ + public KeyPair generateRSAUnsafeKeyPair() throws Exception { + KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); + kpg.initialize(1024); + return kpg.generateKeyPair(); + } + + /** + * Sign data using SHA1withRSA. + * + * CBOM/SAST Notes: - Parent: Legacy Digital Signature. - SHA-1 is + * deprecated and RSA with 1024 bits is considered weak. + */ + public byte[] signSHA1withRSA(PrivateKey privateKey, byte[] data) throws Exception { + Signature signature = Signature.getInstance("SHA1withRSA"); + signature.initSign(privateKey); + signature.update(data); + return signature.sign(); + } + + /** + * Verify data using SHA1withRSA. + * + * CBOM/SAST Notes: - Parent: Legacy Digital Signature. - Verification of + * SHA1withRSA is insecure. + */ + public boolean verifySHA1withRSA(PublicKey publicKey, byte[] data, byte[] sigBytes) throws Exception { + Signature signature = Signature.getInstance("SHA1withRSA"); + signature.initVerify(publicKey); + signature.update(data); + return signature.verify(sigBytes); + } + + /////////////////////////////////////// + // Nuanced Edge-Case Examples + /////////////////////////////////////// + + /** + * Demonstrates signing and verifying an empty message. + * + * CBOM/SAST Notes: + * - Edge Case: Signing empty input should be handled correctly but might be + * unexpected. + */ + public void signAndVerifyEmptyMessage() throws Exception { + byte[] emptyMessage = new byte[0]; + KeyPair kp = generateRSAPSSKeyPair(); + byte[] sig = signRSAPSS(kp.getPrivate(), emptyMessage); + boolean verified = verifyRSAPSS(kp.getPublic(), emptyMessage, sig); + System.out.println("Empty message signature verified? " + verified); + } + + /** + * Demonstrates that even a slight tampering with the signature will cause + * verification to fail. + * + * CBOM/SAST Notes: - Edge Case: Signature integrity is critical. Any + * change-even a single byte-should invalidate the signature. + */ + public void tamperSignatureEdgeCase() throws Exception { + byte[] message = "Important Message".getBytes(); + KeyPair kp = generateECDSAKeyPair(); + byte[] originalSig = signECDSA(kp.getPrivate(), message); + // Tamper with the signature by flipping one bit. + byte[] tamperedSig = originalSig.clone(); + tamperedSig[0] ^= 0x01; + boolean verifiedOriginal = verifyECDSA(kp.getPublic(), message, originalSig); + boolean verifiedTampered = verifyECDSA(kp.getPublic(), message, tamperedSig); + System.out.println("Original ECDSA signature verified? " + verifiedOriginal); + System.out.println("Tampered ECDSA signature verified? " + verifiedTampered); + } + + /** + * Demonstrates dynamic signature algorithm selection. This is a "known + * unknown" scenario where the algorithm is chosen at runtime based on + * configuration. If the configuration is compromised or misconfigured, an + * insecure algorithm might be selected. + * + * CBOM/SAST Notes: - Known Unknown: Dynamic configuration introduces + * ambiguity and risk. - Ensure that fallback defaults are secure. + */ + public void dynamicSignatureSelectionDemo() throws Exception { + // Simulate loading a configuration. + Properties config = new Properties(); + // For demonstration, let's assume the config might specify an algorithm. + // Possible values: "SHA256withRSAandMGF1", "SHA256withECDSA", "Ed25519", + // "SHA1withRSA" + // Here we simulate an unknown or insecure algorithm being selected. + config.setProperty("signature.algorithm", "SHA1withRSA"); // Insecure choice! + String algorithm = config.getProperty("signature.algorithm", "SHA256withRSAandMGF1"); + + KeyPair kp; + Signature signature; + if ("SHA256withRSAandMGF1".equalsIgnoreCase(algorithm)) { + kp = generateRSAPSSKeyPair(); + signature = Signature.getInstance("SHA256withRSAandMGF1"); + } else if ("SHA256withECDSA".equalsIgnoreCase(algorithm)) { + kp = generateECDSAKeyPair(); + signature = Signature.getInstance("SHA256withECDSA", "BC"); + } else if ("Ed25519".equalsIgnoreCase(algorithm)) { + kp = generateEd25519KeyPair(); + signature = Signature.getInstance("Ed25519", "BC"); + } else if ("SHA1withRSA".equalsIgnoreCase(algorithm)) { + kp = generateRSAUnsafeKeyPair(); + signature = Signature.getInstance("SHA1withRSA"); + } else { + // Fallback to a secure default. + kp = generateRSAPSSKeyPair(); + signature = Signature.getInstance("SHA256withRSAandMGF1"); + } + + byte[] message = "Dynamic Signature Demo".getBytes(); + signature.initSign(kp.getPrivate()); + signature.update(message); + byte[] sigBytes = signature.sign(); + // Verify using the same algorithm. + signature.initVerify(kp.getPublic()); + signature.update(message); + boolean verified = signature.verify(sigBytes); + System.out.println("Dynamic algorithm (" + algorithm + ") signature verified? " + verified); + } + + /////////////////////////////////////// + // Demo Method: runSignatureDemos + /////////////////////////////////////// + + /** + * Demonstrates digital signature operations for various algorithms. + * It generates key pairs, signs a message, and verifies the signature for: + * - RSA-PSS + * - ECDSA (secp256r1) + * - Ed25519 + * - SHA1withRSA (deprecated/unsafe) + * Additionally, it runs several edge-case demos. + * + * CBOM/SAST Classification: + * - Shows both modern, secure signature schemes and a deprecated example. + * - Also demonstrates handling of edge cases and dynamic selection risks. + */ + public void runSignatureDemos() throws Exception { + byte[] message = "Hello Signature World!".getBytes(); + + // ============ RSA-PSS ============ + KeyPair rsaPssKP = generateRSAPSSKeyPair(); + byte[] rsaPssSig = signRSAPSS(rsaPssKP.getPrivate(), message); + System.out.println("RSA-PSS Signature: " + Base64.getEncoder().encodeToString(rsaPssSig)); + boolean rsaPssVerified = verifyRSAPSS(rsaPssKP.getPublic(), message, rsaPssSig); + System.out.println("RSA-PSS Verified? " + rsaPssVerified); + + // ============ ECDSA (secp256r1) ============ + KeyPair ecdsaKP = generateECDSAKeyPair(); + byte[] ecdsaSig = signECDSA(ecdsaKP.getPrivate(), message); + System.out.println("ECDSA Signature: " + Base64.getEncoder().encodeToString(ecdsaSig)); + boolean ecdsaVerified = verifyECDSA(ecdsaKP.getPublic(), message, ecdsaSig); + System.out.println("ECDSA Verified? " + ecdsaVerified); + + // ============ Ed25519 ============ + KeyPair ed25519KP = generateEd25519KeyPair(); + byte[] ed25519Sig = signEd25519(ed25519KP.getPrivate(), message); + System.out.println("Ed25519 Signature: " + Base64.getEncoder().encodeToString(ed25519Sig)); + boolean ed25519Verified = verifyEd25519(ed25519KP.getPublic(), message, ed25519Sig); + System.out.println("Ed25519 Verified? " + ed25519Verified); + + // ============ SHA1withRSA (Deprecated/Unsafe) ============ + KeyPair rsaUnsafeKP = generateRSAUnsafeKeyPair(); + byte[] rsaUnsafeSig = signSHA1withRSA(rsaUnsafeKP.getPrivate(), message); + System.out.println("SHA1withRSA Signature (Insecure): " + Base64.getEncoder().encodeToString(rsaUnsafeSig)); + boolean rsaUnsafeVerified = verifySHA1withRSA(rsaUnsafeKP.getPublic(), message, rsaUnsafeSig); + System.out.println("SHA1withRSA Verified? " + rsaUnsafeVerified); + + // ============ Edge Cases ============ + signAndVerifyEmptyMessage(); + tamperSignatureEdgeCase(); + dynamicSignatureSelectionDemo(); + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/SymmetricAlgorithm.java b/java/ql/test/experimental/library-tests/quantum/jca/SymmetricAlgorithm.java new file mode 100644 index 000000000000..ce07eab5b596 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/SymmetricAlgorithm.java @@ -0,0 +1,348 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.*; + +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.Mac; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.IvParameterSpec; +import javax.crypto.spec.SecretKeySpec; +import javax.crypto.SecretKeyFactory; +import javax.crypto.spec.PBEKeySpec; +import java.security.SecureRandom; +import java.util.Arrays; +import java.util.Base64; + +/** + * SymmetricAlgorithmTest demonstrates various symmetric encryption flows and + * key derivation scenarios that can be analyzed by SAST tools. + * + * It includes: 1) AES-GCM encryption with random nonce (secure). 2) AES-GCM + * encryption with fixed nonce (insecure). 3) AES-CBC encryption with random IV + * (secure). 4) AES-ECB encryption (insecure). 5) RC4 encryption (insecure). 6) + * DES and TripleDES encryption (insecure/weak). 7) ChaCha20 encryption (secure, + * if available). 8) KMAC-based key derivation used to derive a key for AES + * encryption. 9) Dynamic symmetric encryption selection based on configuration. + * 10) Further use: deriving two keys from symmetric key material via PBKDF2. + * + * SAST/CBOM notes: - Nonce/IV reuse (e.g., fixed nonce) must be flagged. - + * Insecure algorithms (RC4, DES, TripleDES, AES/ECB) are marked as unsafe. - + * Dynamic selection may lead to insecure fallback if misconfigured. + */ +public class SymmetricAlgorithm { + + // static { + // Security.addProvider(new BouncyCastleProvider()); + // } + // ---------- Secure Symmetric Encryption Flows ---------- + /** + * AES-GCM encryption using a 12-byte random nonce. SAST: AES-GCM is secure + * when a unique nonce is used per encryption. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return The IV prepended to the ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] aesGcmEncryptSafe(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; // Recommended 12-byte nonce for GCM. + new SecureRandom().nextBytes(iv); + GCMParameterSpec spec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.ENCRYPT_MODE, key, spec); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] output = new byte[iv.length + ciphertext.length]; + System.arraycopy(iv, 0, output, 0, iv.length); + System.arraycopy(ciphertext, 0, output, iv.length, ciphertext.length); + return output; + } + + /** + * AES-GCM encryption using a fixed (constant) nonce. SAST: Fixed nonce + * reuse in AES-GCM is insecure as it destroys confidentiality. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return The fixed IV prepended to the ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] aesGcmEncryptUnsafe(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; // Fixed IV (all zeros by default) - insecure. + GCMParameterSpec spec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.ENCRYPT_MODE, key, spec); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] output = new byte[iv.length + ciphertext.length]; + System.arraycopy(iv, 0, output, 0, iv.length); + System.arraycopy(ciphertext, 0, output, iv.length, ciphertext.length); + return output; + } + + /** + * AES-CBC encryption using a random IV. SAST: AES-CBC is secure if IVs are + * random and not reused. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return The IV prepended to the ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] aesCbcEncryptSafe(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); + byte[] iv = new byte[16]; // 16-byte IV for AES block size. + new SecureRandom().nextBytes(iv); + IvParameterSpec ivSpec = new IvParameterSpec(iv); + cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] output = new byte[iv.length + ciphertext.length]; + System.arraycopy(iv, 0, output, 0, iv.length); + System.arraycopy(ciphertext, 0, output, iv.length, ciphertext.length); + return output; + } + + /** + * AES-ECB encryption. SAST: ECB mode is insecure as it does not use an IV, + * revealing data patterns. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] aesEcbEncryptUnsafe(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); + cipher.init(Cipher.ENCRYPT_MODE, key); + return cipher.doFinal(plaintext); + } + + // ---------- Other Symmetric Algorithms ---------- + /** + * RC4 encryption. SAST: RC4 is deprecated due to vulnerabilities. + * + * @param key The RC4 key. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] rc4EncryptUnsafe(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("RC4"); + cipher.init(Cipher.ENCRYPT_MODE, key); + return cipher.doFinal(plaintext); + } + + /** + * DES encryption. SAST: DES is insecure due to its 56-bit effective key + * size. + * + * @param key The DES key. + * @param plaintext The plaintext to encrypt. + * @return The IV prepended to the ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] desEncryptUnsafe(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding"); + byte[] iv = new byte[8]; + new SecureRandom().nextBytes(iv); + IvParameterSpec ivSpec = new IvParameterSpec(iv); + cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] output = new byte[iv.length + ciphertext.length]; + System.arraycopy(iv, 0, output, 0, iv.length); + System.arraycopy(ciphertext, 0, output, iv.length, ciphertext.length); + return output; + } + + /** + * TripleDES (DESede) encryption. SAST: TripleDES is weak by modern + * standards and is deprecated. + * + * @param key The TripleDES key. + * @param plaintext The plaintext to encrypt. + * @return The IV prepended to the ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] tripleDesEncryptUnsafe(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("DESede/CBC/PKCS5Padding"); + byte[] iv = new byte[8]; + new SecureRandom().nextBytes(iv); + IvParameterSpec ivSpec = new IvParameterSpec(iv); + cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] output = new byte[iv.length + ciphertext.length]; + System.arraycopy(iv, 0, output, 0, iv.length); + System.arraycopy(ciphertext, 0, output, iv.length, ciphertext.length); + return output; + } + + /** + * ChaCha20 encryption. SAST: ChaCha20 is considered secure and is a modern + * alternative to AES. + * + * @param key The ChaCha20 key. + * @param plaintext The plaintext to encrypt. + * @return The nonce prepended to the ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] chacha20EncryptSafe(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("ChaCha20", "BC"); + byte[] nonce = new byte[12]; // ChaCha20 typically uses a 12-byte nonce. + new SecureRandom().nextBytes(nonce); + // ChaCha20 may require an IvParameterSpec for the nonce. + cipher.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(nonce)); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] output = new byte[nonce.length + ciphertext.length]; + System.arraycopy(nonce, 0, output, 0, nonce.length); + System.arraycopy(ciphertext, 0, output, nonce.length, ciphertext.length); + return output; + } + + /** + * KMAC-based flow: Uses KMAC128 to derive key material for AES encryption. + * SAST: KMAC128 is secure as part of the SHA-3 family when used correctly. + * + * @param key The KMAC key. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext (with IV) resulting from encryption with a derived + * key. + * @throws Exception if encryption fails. + */ + public byte[] kmacEncryptFlow(SecretKey key, byte[] plaintext) throws Exception { + Mac kmac = Mac.getInstance("KMAC128", "BC"); + kmac.init(key); + byte[] kmacOutput = kmac.doFinal(plaintext); + // Use the first 16 bytes of KMAC output as an AES key. + SecretKey derivedKey = new SecretKeySpec(kmacOutput, 0, 16, "AES"); + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; + new SecureRandom().nextBytes(iv); + GCMParameterSpec spec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.ENCRYPT_MODE, derivedKey, spec); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] output = new byte[iv.length + ciphertext.length]; + System.arraycopy(iv, 0, output, 0, iv.length); + System.arraycopy(ciphertext, 0, output, iv.length, ciphertext.length); + return output; + } + + // ---------- Dynamic Algorithm Selection ---------- + /** + * Dynamically selects a symmetric encryption algorithm based on a + * configuration property. If the algorithm is unknown or ambiguous, falls + * back to an insecure default (AES/ECB). + * + * SAST: Dynamic selection introduces a known unknown risk. + * + * @param algorithm The algorithm name from configuration. + * @param key The symmetric key. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext. + * @throws Exception if encryption fails. + */ + public byte[] dynamicSymmetricEncryption(String algorithm, SecretKey key, byte[] plaintext) throws Exception { + if ("AES/GCM/NoPadding".equalsIgnoreCase(algorithm)) { + return aesGcmEncryptSafe(key, plaintext); + } else if ("AES/CBC/PKCS5Padding".equalsIgnoreCase(algorithm)) { + return aesCbcEncryptSafe(key, plaintext); + } else if ("AES/ECB/PKCS5Padding".equalsIgnoreCase(algorithm)) { + return aesEcbEncryptUnsafe(key, plaintext); + } else if ("RC4".equalsIgnoreCase(algorithm)) { + return rc4EncryptUnsafe(key, plaintext); + } else if ("ChaCha20".equalsIgnoreCase(algorithm)) { + return chacha20EncryptSafe(key, plaintext); + } else { + // Unknown algorithm: fallback to insecure AES/ECB. + return aesEcbEncryptUnsafe(key, plaintext); + } + } + + // ---------- Further Use of Symmetric Keys ---------- + /** + * Derives a key from an input key by simple truncation. SAST: This approach + * is ambiguous; a proper KDF should be used. + * + * @param key The input symmetric key. + * @return A derived 128-bit key. + */ + public byte[] deriveKeyFromKey(SecretKey key) { + byte[] keyBytes = key.getEncoded(); + return Arrays.copyOf(keyBytes, 16); + } + + /** + * Further use: Derives two separate keys from a symmetric key using PBKDF2, + * then uses one key for encryption and one for MACing ciphertext. SAST: + * This key-splitting approach is acceptable if PBKDF2 is used securely. + * + * @param key The input key material. + * @param plaintext The plaintext to encrypt. + * @return The concatenated ciphertext and its MAC. + * @throws Exception if key derivation or encryption fails. + */ + public byte[] furtherUseSymmetricKeyForKeyDerivation(SecretKey key, byte[] plaintext) throws Exception { + String keyAsString = Base64.getEncoder().encodeToString(key.getEncoded()); + byte[] salt = generateSalt(16); + PBEKeySpec spec = new PBEKeySpec(keyAsString.toCharArray(), salt, 10000, 256); + SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256"); + byte[] derived = factory.generateSecret(spec).getEncoded(); + byte[] encKeyBytes = Arrays.copyOfRange(derived, 0, 16); + byte[] macKeyBytes = Arrays.copyOfRange(derived, 16, 32); + SecretKey encKey = new SecretKeySpec(encKeyBytes, "AES"); + SecretKey derivedMacKey = new SecretKeySpec(macKeyBytes, "HmacSHA256"); + + Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding"); + byte[] iv = new byte[12]; + new SecureRandom().nextBytes(iv); + cipher.init(Cipher.ENCRYPT_MODE, encKey, new GCMParameterSpec(128, iv)); + byte[] ciphertext = cipher.doFinal(plaintext); + + Mac mac = Mac.getInstance("HmacSHA256"); + mac.init(derivedMacKey); + byte[] computedMac = mac.doFinal(ciphertext); + + byte[] output = new byte[ciphertext.length + computedMac.length]; + System.arraycopy(ciphertext, 0, output, 0, ciphertext.length); + System.arraycopy(computedMac, 0, output, ciphertext.length, computedMac.length); + storeEncryptedOutput(output); + return output; + } + + /** + * Stores the encrypted output. SAST: In production, secure + * storage/transmission is required. + * + * @param output The output to store. + */ + public void storeEncryptedOutput(byte[] output) { + String stored = Base64.getEncoder().encodeToString(output); + } + + // ---------- Helper Methods ---------- + /** + * Generates a secure 256-bit AES key. SAST: Uses a strong RNG for key + * generation. + * + * @return A new AES SecretKey. + * @throws Exception if key generation fails. + */ + public SecretKey generateAESKey() throws Exception { + KeyGenerator kg = KeyGenerator.getInstance("AES"); + kg.init(256); + return kg.generateKey(); + } + + /** + * Generates a random salt of the specified length using SecureRandom. SAST: + * Salting is essential for secure key derivation. + * + * @param length The salt length. + * @return A byte array representing the salt. + */ + private byte[] generateSalt(int length) { + byte[] salt = new byte[length]; + new SecureRandom().nextBytes(salt); + return salt; + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/SymmetricModesTest.java b/java/ql/test/experimental/library-tests/quantum/jca/SymmetricModesTest.java new file mode 100644 index 000000000000..18df2602a7dd --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/SymmetricModesTest.java @@ -0,0 +1,131 @@ +package com.example.crypto.algorithms; + +//import org.bouncycastle.jce.provider.BouncyCastleProvider; +import java.security.SecureRandom; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import javax.crypto.spec.IvParameterSpec; + +/** + * SymmetricModesTest demonstrates the use of advanced cipher modes for + * symmetric encryption: + * + * 1. AES/KWP/NoPadding: Uses AES Key Wrap with Padding (KWP) to securely wrap + * (encrypt) a key. - Secure usage: Uses a randomly generated wrapping key. + * + * 2. AES/OFB8/NoPadding: Uses AES in Output Feedback mode with an 8-bit + * feedback size. - Secure usage: Uses a random IV for each encryption. - + * Insecure usage: Using a fixed IV (or nonce) in OFB mode compromises + * confidentiality. + * + * In production, algorithm parameters (such as mode, padding, and IV + * generation) should be externalized via configuration files to support crypto + * agility. + */ +public class SymmetricModesTest { + + // static { + // // Register BouncyCastle provider for additional cipher modes. + // Security.addProvider(new BouncyCastleProvider()); + // } + // --------------------------- + // AES/KWP/NoPadding Example + // --------------------------- + /** + * Securely wraps a target AES key using AES/KWP/NoPadding. + * + * Best Practice: - The wrapping key must be generated randomly. - AES/KWP + * provides key wrapping with padding, suitable for keys whose lengths are + * not multiples of the block size. + * + * @return The Base64-encoded wrapped key. + * @throws Exception if an error occurs during key wrapping. + */ + public String secureAESKWPWrap() throws Exception { + // Generate a random wrapping key (256-bit) for key wrapping. + KeyGenerator kg = KeyGenerator.getInstance("AES"); + kg.init(256, new SecureRandom()); + SecretKey wrappingKey = kg.generateKey(); + + // Generate a target AES key to be wrapped (128-bit). + kg.init(128, new SecureRandom()); + SecretKey targetKey = kg.generateKey(); + + // Use AES/KWP (Key Wrap with Padding) to wrap the target key. + Cipher cipher = Cipher.getInstance("AES/KWP/NoPadding", "BC"); + cipher.init(Cipher.WRAP_MODE, wrappingKey); + byte[] wrappedKey = cipher.wrap(targetKey); + + return Base64.getEncoder().encodeToString(wrappedKey); + } + + // --------------------------- + // AES/OFB8/NoPadding Examples + // --------------------------- + /** + * Securely encrypts plaintext using AES in OFB mode with an 8-bit feedback + * size (AES/OFB8/NoPadding). + * + * Best Practice: - Use a fresh, random IV for each encryption operation. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext (Base64-encoded) with the IV prepended. + * @throws Exception if encryption fails. + */ + public String secureAesOfb8Encryption(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/OFB8/NoPadding", "BC"); + byte[] iv = new byte[16]; // IV size for AES block cipher (128-bit) even if feedback is 8-bit. + new SecureRandom().nextBytes(iv); + IvParameterSpec ivSpec = new IvParameterSpec(iv); + cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec); + byte[] ciphertext = cipher.doFinal(plaintext); + // Prepend IV to ciphertext (as is common practice) + byte[] output = new byte[iv.length + ciphertext.length]; + System.arraycopy(iv, 0, output, 0, iv.length); + System.arraycopy(ciphertext, 0, output, iv.length, ciphertext.length); + return Base64.getEncoder().encodeToString(output); + } + + /** + * Insecurely encrypts plaintext using AES in OFB mode with an 8-bit + * feedback size (AES/OFB8/NoPadding) by using a fixed IV. + * + * Best Practice Violation: - Using a fixed IV (or nonce) with any + * encryption mode (including OFB) compromises the cipher's security. + * + * @param key The AES key. + * @param plaintext The plaintext to encrypt. + * @return The ciphertext (Base64-encoded) with the fixed IV prepended. + * @throws Exception if encryption fails. + */ + public String insecureAesOfb8Encryption(SecretKey key, byte[] plaintext) throws Exception { + Cipher cipher = Cipher.getInstance("AES/OFB8/NoPadding", "BC"); + // Fixed IV: Insecure because it causes nonce/IV reuse. + byte[] fixedIV = new byte[16]; // All zeros. + IvParameterSpec ivSpec = new IvParameterSpec(fixedIV); + cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec); + byte[] ciphertext = cipher.doFinal(plaintext); + byte[] output = new byte[fixedIV.length + ciphertext.length]; + System.arraycopy(fixedIV, 0, output, 0, fixedIV.length); + System.arraycopy(ciphertext, 0, output, fixedIV.length, ciphertext.length); + return Base64.getEncoder().encodeToString(output); + } + + // --------------------------- + // Helper Methods + // --------------------------- + /** + * Generates a secure 256-bit AES key. + * + * @return A new AES SecretKey. + * @throws Exception if key generation fails. + */ + public SecretKey generateAESKey() throws Exception { + KeyGenerator kg = KeyGenerator.getInstance("AES"); + kg.init(256, new SecureRandom()); + return kg.generateKey(); + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/jca/UniversalFlowTest.java b/java/ql/test/experimental/library-tests/quantum/jca/UniversalFlowTest.java new file mode 100644 index 000000000000..43a508951f88 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/jca/UniversalFlowTest.java @@ -0,0 +1,49 @@ +package com.example.crypto.algorithms; + +// import org.bouncycastle.jce.provider.BouncyCastleProvider; +import javax.crypto.Cipher; +import javax.crypto.KeyGenerator; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; +import java.security.*; +import java.util.Base64; +import java.util.Random; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.Files; +import java.io.IOException; + +public class UniversalFlowTest { + + public void simpleAESEncryption() throws Exception { + String algorithm = "AES"; + String otherAlgorithm = loadAlgorithmFromDisk(); + + // Randomly select between the known algorithm and the one loaded from disk + String selectedAlgorithm = (new Random().nextInt(2) == 0) ? algorithm : otherAlgorithm; + + KeyGenerator keyGen = KeyGenerator.getInstance(selectedAlgorithm); + keyGen.init(256); // 256-bit AES key. + SecretKey key = keyGen.generateKey(); + String algorithm2 = "AES/GCM/NoPadding"; + Cipher cipher = Cipher.getInstance(algorithm2); + byte[] iv = new byte[12]; // 12-byte IV recommended for GCM. + new SecureRandom().nextBytes(iv); + GCMParameterSpec gcmSpec = new GCMParameterSpec(128, iv); // 128-bit authentication tag. + cipher.init(Cipher.ENCRYPT_MODE, key, gcmSpec); + byte[] encryptedData = cipher.doFinal("Sensitive Data".getBytes()); + } + +// Method to load algorithm from disk + private String loadAlgorithmFromDisk() { + try { + // Implementation to load algorithm name from a file + Path path = Paths.get("algorithm.txt"); + return Files.readString(path).trim(); + } catch (IOException e) { + // Fallback to default algorithm if loading fails + System.err.println("Failed to load algorithm from disk: " + e.getMessage()); + return "AES"; + } + } +} diff --git a/java/ql/test/experimental/library-tests/quantum/node_edges.expected b/java/ql/test/experimental/library-tests/quantum/node_edges.expected new file mode 100644 index 000000000000..94e4d2bf0561 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/node_edges.expected @@ -0,0 +1,1725 @@ +| jca/AesWrapAndPBEWith.java:60:33:60:48 | KeyGeneration | Algorithm | jca/AesWrapAndPBEWith.java:58:52:58:56 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:60:33:60:48 | KeyGeneration | Output | jca/AesWrapAndPBEWith.java:60:33:60:48 | Key | +| jca/AesWrapAndPBEWith.java:63:31:63:46 | KeyGeneration | Algorithm | jca/AesWrapAndPBEWith.java:58:52:58:56 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:63:31:63:46 | KeyGeneration | Output | jca/AesWrapAndPBEWith.java:63:31:63:46 | Key | +| jca/AesWrapAndPBEWith.java:65:44:65:52 | KeyOperationAlgorithm | Mode | jca/AesWrapAndPBEWith.java:65:44:65:52 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:65:44:65:52 | KeyOperationAlgorithm | Padding | jca/AesWrapAndPBEWith.java:65:44:65:52 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:66:39:66:49 | Key | Source | jca/AesWrapAndPBEWith.java:60:33:60:48 | Key | +| jca/AesWrapAndPBEWith.java:67:29:67:50 | WrapOperation | Algorithm | jca/AesWrapAndPBEWith.java:65:44:65:52 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:67:29:67:50 | WrapOperation | Input | jca/AesWrapAndPBEWith.java:67:41:67:49 | Message | +| jca/AesWrapAndPBEWith.java:67:29:67:50 | WrapOperation | Key | jca/AesWrapAndPBEWith.java:66:39:66:49 | Key | +| jca/AesWrapAndPBEWith.java:67:29:67:50 | WrapOperation | Nonce | jca/AesWrapAndPBEWith.java:67:29:67:50 | WrapOperation | +| jca/AesWrapAndPBEWith.java:67:29:67:50 | WrapOperation | Output | jca/AesWrapAndPBEWith.java:67:29:67:50 | KeyOperationOutput | +| jca/AesWrapAndPBEWith.java:67:41:67:49 | Message | Source | jca/AesWrapAndPBEWith.java:63:31:63:46 | Key | +| jca/AesWrapAndPBEWith.java:85:31:85:46 | KeyGeneration | Algorithm | jca/AesWrapAndPBEWith.java:83:52:83:56 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:85:31:85:46 | KeyGeneration | Output | jca/AesWrapAndPBEWith.java:85:31:85:46 | Key | +| jca/AesWrapAndPBEWith.java:87:44:87:52 | KeyOperationAlgorithm | Mode | jca/AesWrapAndPBEWith.java:87:44:87:52 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:87:44:87:52 | KeyOperationAlgorithm | Padding | jca/AesWrapAndPBEWith.java:87:44:87:52 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:88:39:88:49 | Key | Source | jca/AesWrapAndPBEWith.java:88:39:88:49 | Key | +| jca/AesWrapAndPBEWith.java:89:29:89:50 | WrapOperation | Algorithm | jca/AesWrapAndPBEWith.java:87:44:87:52 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:89:29:89:50 | WrapOperation | Input | jca/AesWrapAndPBEWith.java:89:41:89:49 | Message | +| jca/AesWrapAndPBEWith.java:89:29:89:50 | WrapOperation | Key | jca/AesWrapAndPBEWith.java:88:39:88:49 | Key | +| jca/AesWrapAndPBEWith.java:89:29:89:50 | WrapOperation | Nonce | jca/AesWrapAndPBEWith.java:89:29:89:50 | WrapOperation | +| jca/AesWrapAndPBEWith.java:89:29:89:50 | WrapOperation | Output | jca/AesWrapAndPBEWith.java:89:29:89:50 | KeyOperationOutput | +| jca/AesWrapAndPBEWith.java:89:41:89:49 | Message | Source | jca/AesWrapAndPBEWith.java:85:31:85:46 | Key | +| jca/AesWrapAndPBEWith.java:107:42:107:63 | Message | Source | jca/AesWrapAndPBEWith.java:200:55:200:69 | Parameter | +| jca/AesWrapAndPBEWith.java:107:66:107:69 | Salt | Source | jca/AesWrapAndPBEWith.java:106:34:106:37 | Constant | +| jca/AesWrapAndPBEWith.java:109:27:109:54 | KeyDerivation | Algorithm | jca/AesWrapAndPBEWith.java:108:65:108:82 | KeyDerivationAlgorithm | +| jca/AesWrapAndPBEWith.java:109:27:109:54 | KeyDerivation | Input | jca/AesWrapAndPBEWith.java:107:42:107:63 | Message | +| jca/AesWrapAndPBEWith.java:109:27:109:54 | KeyDerivation | Output | jca/AesWrapAndPBEWith.java:109:27:109:54 | Key | +| jca/AesWrapAndPBEWith.java:109:27:109:54 | KeyDerivation | Salt | jca/AesWrapAndPBEWith.java:107:66:107:69 | Salt | +| jca/AesWrapAndPBEWith.java:123:42:123:63 | Message | Source | jca/AesWrapAndPBEWith.java:200:55:200:69 | Parameter | +| jca/AesWrapAndPBEWith.java:123:66:123:69 | Salt | Source | jca/AesWrapAndPBEWith.java:122:9:122:42 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:123:66:123:69 | Salt | Source | jca/AesWrapAndPBEWith.java:122:38:122:41 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | HMACAlgorithm | H | jca/AesWrapAndPBEWith.java:124:65:124:86 | HashAlgorithm | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | KeyDerivationAlgorithm | PRF | jca/AesWrapAndPBEWith.java:124:65:124:86 | HMACAlgorithm | +| jca/AesWrapAndPBEWith.java:125:27:125:54 | KeyDerivation | Algorithm | jca/AesWrapAndPBEWith.java:124:65:124:86 | KeyDerivationAlgorithm | +| jca/AesWrapAndPBEWith.java:125:27:125:54 | KeyDerivation | Input | jca/AesWrapAndPBEWith.java:123:42:123:63 | Message | +| jca/AesWrapAndPBEWith.java:125:27:125:54 | KeyDerivation | Output | jca/AesWrapAndPBEWith.java:125:27:125:54 | Key | +| jca/AesWrapAndPBEWith.java:125:27:125:54 | KeyDerivation | Salt | jca/AesWrapAndPBEWith.java:123:66:123:69 | Salt | +| jca/AesWrapAndPBEWith.java:141:42:141:63 | Message | Source | jca/AesWrapAndPBEWith.java:200:55:200:69 | Parameter | +| jca/AesWrapAndPBEWith.java:141:66:141:69 | Salt | Source | jca/AesWrapAndPBEWith.java:140:9:140:42 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:141:66:141:69 | Salt | Source | jca/AesWrapAndPBEWith.java:140:38:140:41 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:143:28:143:55 | KeyDerivation | Algorithm | jca/AesWrapAndPBEWith.java:142:65:142:98 | KeyDerivationAlgorithm | +| jca/AesWrapAndPBEWith.java:143:28:143:55 | KeyDerivation | Input | jca/AesWrapAndPBEWith.java:141:42:141:63 | Message | +| jca/AesWrapAndPBEWith.java:143:28:143:55 | KeyDerivation | Output | jca/AesWrapAndPBEWith.java:143:28:143:55 | Key | +| jca/AesWrapAndPBEWith.java:143:28:143:55 | KeyDerivation | Salt | jca/AesWrapAndPBEWith.java:141:66:141:69 | Salt | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | KeyOperationAlgorithm | Mode | jca/AesWrapAndPBEWith.java:146:44:146:65 | ModeOfOperation | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | KeyOperationAlgorithm | Padding | jca/AesWrapAndPBEWith.java:146:44:146:65 | PaddingAlgorithm | +| jca/AesWrapAndPBEWith.java:150:42:150:47 | Key | Source | jca/AesWrapAndPBEWith.java:150:42:150:47 | Key | +| jca/AesWrapAndPBEWith.java:150:50:150:55 | Nonce | Source | jca/AesWrapAndPBEWith.java:148:9:148:40 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:150:50:150:55 | Nonce | Source | jca/AesWrapAndPBEWith.java:148:38:148:39 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:151:29:151:64 | EncryptOperation | Algorithm | jca/AesWrapAndPBEWith.java:146:44:146:65 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:151:29:151:64 | EncryptOperation | Input | jca/AesWrapAndPBEWith.java:151:44:151:63 | Message | +| jca/AesWrapAndPBEWith.java:151:29:151:64 | EncryptOperation | Key | jca/AesWrapAndPBEWith.java:150:42:150:47 | Key | +| jca/AesWrapAndPBEWith.java:151:29:151:64 | EncryptOperation | Nonce | jca/AesWrapAndPBEWith.java:150:50:150:55 | Nonce | +| jca/AesWrapAndPBEWith.java:151:29:151:64 | EncryptOperation | Output | jca/AesWrapAndPBEWith.java:151:29:151:64 | KeyOperationOutput | +| jca/AesWrapAndPBEWith.java:151:44:151:63 | Message | Source | jca/AesWrapAndPBEWith.java:200:72:200:87 | Parameter | +| jca/AesWrapAndPBEWith.java:168:42:168:63 | Message | Source | jca/AesWrapAndPBEWith.java:200:55:200:69 | Parameter | +| jca/AesWrapAndPBEWith.java:168:66:168:69 | Salt | Source | jca/AesWrapAndPBEWith.java:167:9:167:42 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:168:66:168:69 | Salt | Source | jca/AesWrapAndPBEWith.java:167:38:167:41 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:170:28:170:55 | KeyDerivation | Algorithm | jca/AesWrapAndPBEWith.java:169:65:169:96 | KeyDerivationAlgorithm | +| jca/AesWrapAndPBEWith.java:170:28:170:55 | KeyDerivation | Input | jca/AesWrapAndPBEWith.java:168:42:168:63 | Message | +| jca/AesWrapAndPBEWith.java:170:28:170:55 | KeyDerivation | Output | jca/AesWrapAndPBEWith.java:170:28:170:55 | Key | +| jca/AesWrapAndPBEWith.java:170:28:170:55 | KeyDerivation | Salt | jca/AesWrapAndPBEWith.java:168:66:168:69 | Salt | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | KeyOperationAlgorithm | Mode | jca/AesWrapAndPBEWith.java:173:44:173:65 | ModeOfOperation | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | KeyOperationAlgorithm | Padding | jca/AesWrapAndPBEWith.java:173:44:173:65 | PaddingAlgorithm | +| jca/AesWrapAndPBEWith.java:177:42:177:47 | Key | Source | jca/AesWrapAndPBEWith.java:177:42:177:47 | Key | +| jca/AesWrapAndPBEWith.java:177:50:177:55 | Nonce | Source | jca/AesWrapAndPBEWith.java:175:9:175:40 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:177:50:177:55 | Nonce | Source | jca/AesWrapAndPBEWith.java:175:38:175:39 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:178:29:178:64 | EncryptOperation | Algorithm | jca/AesWrapAndPBEWith.java:173:44:173:65 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:178:29:178:64 | EncryptOperation | Input | jca/AesWrapAndPBEWith.java:178:44:178:63 | Message | +| jca/AesWrapAndPBEWith.java:178:29:178:64 | EncryptOperation | Key | jca/AesWrapAndPBEWith.java:177:42:177:47 | Key | +| jca/AesWrapAndPBEWith.java:178:29:178:64 | EncryptOperation | Nonce | jca/AesWrapAndPBEWith.java:177:50:177:55 | Nonce | +| jca/AesWrapAndPBEWith.java:178:29:178:64 | EncryptOperation | Output | jca/AesWrapAndPBEWith.java:178:29:178:64 | KeyOperationOutput | +| jca/AesWrapAndPBEWith.java:178:44:178:63 | Message | Source | jca/AesWrapAndPBEWith.java:200:72:200:87 | Parameter | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | Key | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | EllipticCurve | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | KeyGeneration | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | EllipticCurve | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | KeyGeneration | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:96:16:96:36 | Key | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:94:61:94:68 | KeyAgreementAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:96:16:96:36 | KeyGeneration | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:94:61:94:68 | KeyAgreementAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:96:16:96:36 | KeyGeneration | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:96:16:96:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:109:17:109:26 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:110:20:110:28 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | KeyAgreementOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:215:91:215:96 | KeyAgreementAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | KeyAgreementOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:239:95:239:100 | KeyAgreementAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | KeyAgreementOperation | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | SharedSecret | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | KeyAgreementOperation | PeerKey | jca/AsymmetricEncryptionMacHybridCryptosystem.java:110:20:110:28 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | KeyAgreementOperation | ServerKey | jca/AsymmetricEncryptionMacHybridCryptosystem.java:109:17:109:26 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | SharedSecret | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | SharedSecret | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:23:124:42 | Digest | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:23:124:42 | Digest | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:23:124:42 | HashOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | HashAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:23:124:42 | HashOperation | Digest | jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:23:124:42 | Digest | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:23:124:42 | HashOperation | Message | jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:37:124:41 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:37:124:41 | Message | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | SharedSecret | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | Key | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | KeyGeneration | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | KeyGeneration | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | Key | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | KeyGeneration | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | KeyGeneration | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | KeyOperationAlgorithm | Mode | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | KeyOperationAlgorithm | Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | PaddingAlgorithm | MD | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | HashAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | PaddingAlgorithm | MGF1Hash | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:167:42:167:58 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | WrapOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | WrapOperation | Input | jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:49:168:54 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | WrapOperation | Key | jca/AsymmetricEncryptionMacHybridCryptosystem.java:167:42:167:58 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | WrapOperation | Nonce | jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | WrapOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | WrapOperation | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:49:168:54 | Message | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | KeyOperationAlgorithm | Mode | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | KeyOperationAlgorithm | Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:45:173:50 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:45:173:50 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:53:173:81 | Nonce | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:9:171:40 | RandomNumberGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:53:173:81 | Nonce | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:38:171:39 | RandomNumberGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | EncryptOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | EncryptOperation | Input | jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:47:174:55 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | EncryptOperation | Key | jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:45:173:50 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | EncryptOperation | Nonce | jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:53:173:81 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | EncryptOperation | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:47:174:55 | Message | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:271:58:271:73 | Parameter | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | KeyOperationAlgorithm | Mode | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | KeyOperationAlgorithm | Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:191:42:191:58 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | WrapOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | WrapOperation | Input | jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:49:192:54 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | WrapOperation | Key | jca/AsymmetricEncryptionMacHybridCryptosystem.java:191:42:191:58 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | WrapOperation | Nonce | jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | WrapOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | WrapOperation | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:49:192:54 | Message | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | KeyOperationAlgorithm | Mode | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | KeyOperationAlgorithm | Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:45:196:50 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:45:196:50 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:53:196:86 | Nonce | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:53:196:86 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | EncryptOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | EncryptOperation | Input | jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:47:197:55 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | EncryptOperation | Key | jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:45:196:50 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | EncryptOperation | Nonce | jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:53:196:86 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | EncryptOperation | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:47:197:55 | Message | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:271:58:271:73 | Parameter | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | KeyOperationAlgorithm | Mode | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | KeyOperationAlgorithm | Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:42:222:47 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:42:222:47 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:50:222:78 | Nonce | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:9:220:40 | RandomNumberGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:50:222:78 | Nonce | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:38:220:39 | RandomNumberGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | EncryptOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | EncryptOperation | Input | jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:44:223:52 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | EncryptOperation | Key | jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:42:222:47 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | EncryptOperation | Nonce | jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:50:222:78 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | EncryptOperation | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:44:223:52 | Message | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:271:58:271:73 | Parameter | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | KeyOperationAlgorithm | Mode | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | KeyOperationAlgorithm | Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:42:245:47 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:42:245:47 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:50:245:83 | Nonce | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:50:245:83 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | EncryptOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | EncryptOperation | Input | jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:44:246:52 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | EncryptOperation | Key | jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:42:245:47 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | EncryptOperation | Nonce | jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:50:245:83 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | EncryptOperation | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:44:246:52 | Message | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:271:58:271:73 | Parameter | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | KeyOperationAlgorithm | Mode | jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | KeyOperationAlgorithm | Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:297:18:297:26 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:297:18:297:26 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | HashAlgorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | Input | jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:28:298:45 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | Key | jca/AsymmetricEncryptionMacHybridCryptosystem.java:297:18:297:26 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | Message | jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:28:298:45 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | Nonce | jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:28:298:45 | Message | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:28:298:45 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | KeyOperationAlgorithm | Mode | jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | KeyOperationAlgorithm | Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:308:18:308:26 | Key | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:308:18:308:26 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | HashAlgorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | Input | jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:28:309:45 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | Key | jca/AsymmetricEncryptionMacHybridCryptosystem.java:308:18:308:26 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | Message | jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:28:309:45 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | Nonce | jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:28:309:45 | Message | Source | jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:28:309:45 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | KeyGeneration | Algorithm | jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | KeyGeneration | Output | jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | Key | +| jca/ChainedEncryptionTest.java:19:44:19:62 | KeyOperationAlgorithm | Mode | jca/ChainedEncryptionTest.java:19:44:19:62 | ModeOfOperation | +| jca/ChainedEncryptionTest.java:19:44:19:62 | KeyOperationAlgorithm | Padding | jca/ChainedEncryptionTest.java:19:44:19:62 | PaddingAlgorithm | +| jca/ChainedEncryptionTest.java:23:42:23:44 | Key | Source | jca/ChainedEncryptionTest.java:119:28:119:47 | Key | +| jca/ChainedEncryptionTest.java:23:47:23:50 | Nonce | Source | jca/ChainedEncryptionTest.java:21:9:21:40 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:23:47:23:50 | Nonce | Source | jca/ChainedEncryptionTest.java:21:38:21:39 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:24:29:24:53 | EncryptOperation | Algorithm | jca/ChainedEncryptionTest.java:19:44:19:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:24:29:24:53 | EncryptOperation | Input | jca/ChainedEncryptionTest.java:24:44:24:52 | Message | +| jca/ChainedEncryptionTest.java:24:29:24:53 | EncryptOperation | Key | jca/ChainedEncryptionTest.java:23:42:23:44 | Key | +| jca/ChainedEncryptionTest.java:24:29:24:53 | EncryptOperation | Nonce | jca/ChainedEncryptionTest.java:23:47:23:50 | Nonce | +| jca/ChainedEncryptionTest.java:24:29:24:53 | EncryptOperation | Output | jca/ChainedEncryptionTest.java:24:29:24:53 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:24:44:24:52 | Message | Source | jca/ChainedEncryptionTest.java:126:31:126:57 | Constant | +| jca/ChainedEncryptionTest.java:32:44:32:62 | KeyOperationAlgorithm | Mode | jca/ChainedEncryptionTest.java:32:44:32:62 | ModeOfOperation | +| jca/ChainedEncryptionTest.java:32:44:32:62 | KeyOperationAlgorithm | Padding | jca/ChainedEncryptionTest.java:32:44:32:62 | PaddingAlgorithm | +| jca/ChainedEncryptionTest.java:34:42:34:44 | Key | Source | jca/ChainedEncryptionTest.java:119:28:119:47 | Key | +| jca/ChainedEncryptionTest.java:34:47:34:50 | Nonce | Source | jca/ChainedEncryptionTest.java:34:47:34:50 | Nonce | +| jca/ChainedEncryptionTest.java:35:16:35:41 | DecryptOperation | Algorithm | jca/ChainedEncryptionTest.java:32:44:32:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:35:16:35:41 | DecryptOperation | Input | jca/ChainedEncryptionTest.java:35:31:35:40 | Message | +| jca/ChainedEncryptionTest.java:35:16:35:41 | DecryptOperation | Key | jca/ChainedEncryptionTest.java:34:42:34:44 | Key | +| jca/ChainedEncryptionTest.java:35:16:35:41 | DecryptOperation | Nonce | jca/ChainedEncryptionTest.java:34:47:34:50 | Nonce | +| jca/ChainedEncryptionTest.java:35:16:35:41 | DecryptOperation | Output | jca/ChainedEncryptionTest.java:35:16:35:41 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:35:31:35:40 | Message | Source | jca/ChainedEncryptionTest.java:35:31:35:40 | Message | +| jca/ChainedEncryptionTest.java:40:44:40:62 | KeyOperationAlgorithm | Mode | jca/ChainedEncryptionTest.java:40:44:40:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:40:44:40:62 | KeyOperationAlgorithm | Padding | jca/ChainedEncryptionTest.java:40:44:40:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:43:42:43:44 | Key | Source | jca/ChainedEncryptionTest.java:124:31:124:53 | Key | +| jca/ChainedEncryptionTest.java:43:47:43:72 | Nonce | Source | jca/ChainedEncryptionTest.java:42:9:42:43 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:43:47:43:72 | Nonce | Source | jca/ChainedEncryptionTest.java:42:38:42:42 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:44:29:44:53 | EncryptOperation | Algorithm | jca/ChainedEncryptionTest.java:40:44:40:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:44:29:44:53 | EncryptOperation | Input | jca/ChainedEncryptionTest.java:44:44:44:52 | Message | +| jca/ChainedEncryptionTest.java:44:29:44:53 | EncryptOperation | Key | jca/ChainedEncryptionTest.java:43:42:43:44 | Key | +| jca/ChainedEncryptionTest.java:44:29:44:53 | EncryptOperation | Nonce | jca/ChainedEncryptionTest.java:43:47:43:72 | Nonce | +| jca/ChainedEncryptionTest.java:44:29:44:53 | EncryptOperation | Output | jca/ChainedEncryptionTest.java:44:29:44:53 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:44:44:44:52 | Message | Source | jca/ChainedEncryptionTest.java:44:44:44:52 | Message | +| jca/ChainedEncryptionTest.java:52:44:52:62 | KeyOperationAlgorithm | Mode | jca/ChainedEncryptionTest.java:52:44:52:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:52:44:52:62 | KeyOperationAlgorithm | Padding | jca/ChainedEncryptionTest.java:52:44:52:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:53:42:53:44 | Key | Source | jca/ChainedEncryptionTest.java:124:31:124:53 | Key | +| jca/ChainedEncryptionTest.java:53:47:53:72 | Nonce | Source | jca/ChainedEncryptionTest.java:53:47:53:72 | Nonce | +| jca/ChainedEncryptionTest.java:54:16:54:41 | DecryptOperation | Algorithm | jca/ChainedEncryptionTest.java:52:44:52:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:54:16:54:41 | DecryptOperation | Input | jca/ChainedEncryptionTest.java:54:31:54:40 | Message | +| jca/ChainedEncryptionTest.java:54:16:54:41 | DecryptOperation | Key | jca/ChainedEncryptionTest.java:53:42:53:44 | Key | +| jca/ChainedEncryptionTest.java:54:16:54:41 | DecryptOperation | Nonce | jca/ChainedEncryptionTest.java:53:47:53:72 | Nonce | +| jca/ChainedEncryptionTest.java:54:16:54:41 | DecryptOperation | Output | jca/ChainedEncryptionTest.java:54:16:54:41 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:54:31:54:40 | Message | Source | jca/ChainedEncryptionTest.java:54:31:54:40 | Message | +| jca/ChainedEncryptionTest.java:81:30:81:49 | KeyGeneration | Algorithm | jca/ChainedEncryptionTest.java:79:56:79:60 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:81:30:81:49 | KeyGeneration | Output | jca/ChainedEncryptionTest.java:81:30:81:49 | Key | +| jca/ChainedEncryptionTest.java:85:30:85:52 | KeyGeneration | Algorithm | jca/ChainedEncryptionTest.java:83:59:83:68 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:85:30:85:52 | KeyGeneration | Output | jca/ChainedEncryptionTest.java:85:30:85:52 | Key | +| jca/ChainedEncryptionTest.java:90:47:90:65 | KeyOperationAlgorithm | Mode | jca/ChainedEncryptionTest.java:90:47:90:65 | ModeOfOperation | +| jca/ChainedEncryptionTest.java:90:47:90:65 | KeyOperationAlgorithm | Padding | jca/ChainedEncryptionTest.java:90:47:90:65 | PaddingAlgorithm | +| jca/ChainedEncryptionTest.java:92:45:92:52 | Key | Source | jca/ChainedEncryptionTest.java:81:30:81:49 | Key | +| jca/ChainedEncryptionTest.java:92:55:92:61 | Nonce | Source | jca/ChainedEncryptionTest.java:89:9:89:43 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:92:55:92:61 | Nonce | Source | jca/ChainedEncryptionTest.java:89:38:89:42 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:93:34:93:62 | EncryptOperation | Algorithm | jca/ChainedEncryptionTest.java:90:47:90:65 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:93:34:93:62 | EncryptOperation | Input | jca/ChainedEncryptionTest.java:93:52:93:61 | Message | +| jca/ChainedEncryptionTest.java:93:34:93:62 | EncryptOperation | Key | jca/ChainedEncryptionTest.java:92:45:92:52 | Key | +| jca/ChainedEncryptionTest.java:93:34:93:62 | EncryptOperation | Nonce | jca/ChainedEncryptionTest.java:92:55:92:61 | Nonce | +| jca/ChainedEncryptionTest.java:93:34:93:62 | EncryptOperation | Output | jca/ChainedEncryptionTest.java:93:34:93:62 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:93:52:93:61 | Message | Source | jca/ChainedEncryptionTest.java:75:46:75:61 | Parameter | +| jca/ChainedEncryptionTest.java:98:50:98:68 | KeyOperationAlgorithm | Mode | jca/ChainedEncryptionTest.java:98:50:98:68 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:98:50:98:68 | KeyOperationAlgorithm | Padding | jca/ChainedEncryptionTest.java:98:50:98:68 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:99:48:99:55 | Key | Source | jca/ChainedEncryptionTest.java:85:30:85:52 | Key | +| jca/ChainedEncryptionTest.java:99:58:99:89 | Nonce | Source | jca/ChainedEncryptionTest.java:97:9:97:49 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:99:58:99:89 | Nonce | Source | jca/ChainedEncryptionTest.java:97:38:97:48 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:100:34:100:70 | EncryptOperation | Algorithm | jca/ChainedEncryptionTest.java:98:50:98:68 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:100:34:100:70 | EncryptOperation | Input | jca/ChainedEncryptionTest.java:100:55:100:69 | Message | +| jca/ChainedEncryptionTest.java:100:34:100:70 | EncryptOperation | Key | jca/ChainedEncryptionTest.java:99:48:99:55 | Key | +| jca/ChainedEncryptionTest.java:100:34:100:70 | EncryptOperation | Nonce | jca/ChainedEncryptionTest.java:99:58:99:89 | Nonce | +| jca/ChainedEncryptionTest.java:100:34:100:70 | EncryptOperation | Output | jca/ChainedEncryptionTest.java:100:34:100:70 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:100:55:100:69 | Message | Source | jca/ChainedEncryptionTest.java:93:34:93:62 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:103:47:103:65 | KeyOperationAlgorithm | Mode | jca/ChainedEncryptionTest.java:103:47:103:65 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:103:47:103:65 | KeyOperationAlgorithm | Padding | jca/ChainedEncryptionTest.java:103:47:103:65 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:104:45:104:52 | Key | Source | jca/ChainedEncryptionTest.java:104:45:104:52 | Key | +| jca/ChainedEncryptionTest.java:104:55:104:86 | Nonce | Source | jca/ChainedEncryptionTest.java:97:9:97:49 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:104:55:104:86 | Nonce | Source | jca/ChainedEncryptionTest.java:97:38:97:48 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:105:43:105:76 | DecryptOperation | Algorithm | jca/ChainedEncryptionTest.java:103:47:103:65 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:105:43:105:76 | DecryptOperation | Input | jca/ChainedEncryptionTest.java:105:61:105:75 | Message | +| jca/ChainedEncryptionTest.java:105:43:105:76 | DecryptOperation | Key | jca/ChainedEncryptionTest.java:104:45:104:52 | Key | +| jca/ChainedEncryptionTest.java:105:43:105:76 | DecryptOperation | Nonce | jca/ChainedEncryptionTest.java:104:55:104:86 | Nonce | +| jca/ChainedEncryptionTest.java:105:43:105:76 | DecryptOperation | Output | jca/ChainedEncryptionTest.java:105:43:105:76 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:105:61:105:75 | Message | Source | jca/ChainedEncryptionTest.java:100:34:100:70 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:108:44:108:62 | KeyOperationAlgorithm | Mode | jca/ChainedEncryptionTest.java:108:44:108:62 | ModeOfOperation | +| jca/ChainedEncryptionTest.java:108:44:108:62 | KeyOperationAlgorithm | Padding | jca/ChainedEncryptionTest.java:108:44:108:62 | PaddingAlgorithm | +| jca/ChainedEncryptionTest.java:109:42:109:49 | Key | Source | jca/ChainedEncryptionTest.java:109:42:109:49 | Key | +| jca/ChainedEncryptionTest.java:109:52:109:83 | Nonce | Source | jca/ChainedEncryptionTest.java:89:9:89:43 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:109:52:109:83 | Nonce | Source | jca/ChainedEncryptionTest.java:89:38:89:42 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:110:37:110:76 | DecryptOperation | Algorithm | jca/ChainedEncryptionTest.java:108:44:108:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:110:37:110:76 | DecryptOperation | Input | jca/ChainedEncryptionTest.java:110:52:110:75 | Message | +| jca/ChainedEncryptionTest.java:110:37:110:76 | DecryptOperation | Key | jca/ChainedEncryptionTest.java:109:42:109:49 | Key | +| jca/ChainedEncryptionTest.java:110:37:110:76 | DecryptOperation | Nonce | jca/ChainedEncryptionTest.java:109:52:109:83 | Nonce | +| jca/ChainedEncryptionTest.java:110:37:110:76 | DecryptOperation | Output | jca/ChainedEncryptionTest.java:110:37:110:76 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:110:52:110:75 | Message | Source | jca/ChainedEncryptionTest.java:105:43:105:76 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:119:28:119:47 | KeyGeneration | Algorithm | jca/ChainedEncryptionTest.java:117:56:117:60 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:119:28:119:47 | KeyGeneration | Output | jca/ChainedEncryptionTest.java:119:28:119:47 | Key | +| jca/ChainedEncryptionTest.java:124:31:124:53 | KeyGeneration | Algorithm | jca/ChainedEncryptionTest.java:122:59:122:68 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:124:31:124:53 | KeyGeneration | Output | jca/ChainedEncryptionTest.java:124:31:124:53 | Key | +| jca/Digest.java:55:23:55:66 | Digest | Source | jca/Digest.java:55:23:55:66 | Digest | +| jca/Digest.java:55:23:55:66 | HashOperation | Algorithm | jca/Digest.java:54:58:54:66 | HashAlgorithm | +| jca/Digest.java:55:23:55:66 | HashOperation | Digest | jca/Digest.java:55:23:55:66 | Digest | +| jca/Digest.java:55:23:55:66 | HashOperation | Message | jca/Digest.java:55:37:55:65 | Message | +| jca/Digest.java:55:37:55:65 | Message | Source | jca/Digest.java:55:37:55:54 | Constant | +| jca/Digest.java:65:23:65:70 | Digest | Source | jca/Digest.java:65:23:65:70 | Digest | +| jca/Digest.java:65:23:65:70 | HashOperation | Algorithm | jca/Digest.java:64:61:64:65 | HashAlgorithm | +| jca/Digest.java:65:23:65:70 | HashOperation | Digest | jca/Digest.java:65:23:65:70 | Digest | +| jca/Digest.java:65:23:65:70 | HashOperation | Message | jca/Digest.java:65:40:65:69 | Message | +| jca/Digest.java:65:40:65:69 | Message | Source | jca/Digest.java:65:40:65:58 | Constant | +| jca/Digest.java:75:23:75:62 | Digest | Source | jca/Digest.java:75:23:75:62 | Digest | +| jca/Digest.java:75:23:75:62 | HashOperation | Algorithm | jca/Digest.java:74:64:74:72 | HashAlgorithm | +| jca/Digest.java:75:23:75:62 | HashOperation | Digest | jca/Digest.java:75:23:75:62 | Digest | +| jca/Digest.java:75:23:75:62 | HashOperation | Message | jca/Digest.java:75:43:75:61 | Message | +| jca/Digest.java:75:43:75:61 | Message | Source | jca/Digest.java:73:49:73:63 | Parameter | +| jca/Digest.java:86:23:86:26 | Message | Source | jca/Digest.java:253:9:253:42 | RandomNumberGeneration | +| jca/Digest.java:86:23:86:26 | Message | Source | jca/Digest.java:253:38:253:41 | RandomNumberGeneration | +| jca/Digest.java:87:23:87:56 | Digest | Source | jca/Digest.java:87:23:87:56 | Digest | +| jca/Digest.java:87:23:87:56 | HashOperation | Algorithm | jca/Digest.java:85:58:85:66 | HashAlgorithm | +| jca/Digest.java:87:23:87:56 | HashOperation | Digest | jca/Digest.java:87:23:87:56 | Digest | +| jca/Digest.java:87:23:87:56 | HashOperation | Message | jca/Digest.java:86:23:86:26 | Message | +| jca/Digest.java:87:23:87:56 | HashOperation | Message | jca/Digest.java:87:37:87:55 | Message | +| jca/Digest.java:87:37:87:55 | Message | Source | jca/Digest.java:83:37:83:51 | Parameter | +| jca/Digest.java:97:42:97:63 | Message | Source | jca/Digest.java:95:37:95:51 | Parameter | +| jca/Digest.java:97:66:97:69 | Salt | Source | jca/Digest.java:253:9:253:42 | RandomNumberGeneration | +| jca/Digest.java:97:66:97:69 | Salt | Source | jca/Digest.java:253:38:253:41 | RandomNumberGeneration | +| jca/Digest.java:98:65:98:86 | HMACAlgorithm | H | jca/Digest.java:98:65:98:86 | HashAlgorithm | +| jca/Digest.java:98:65:98:86 | KeyDerivationAlgorithm | PRF | jca/Digest.java:98:65:98:86 | HMACAlgorithm | +| jca/Digest.java:99:23:99:50 | KeyDerivation | Algorithm | jca/Digest.java:98:65:98:86 | KeyDerivationAlgorithm | +| jca/Digest.java:99:23:99:50 | KeyDerivation | Input | jca/Digest.java:97:42:97:63 | Message | +| jca/Digest.java:99:23:99:50 | KeyDerivation | Output | jca/Digest.java:99:23:99:50 | Key | +| jca/Digest.java:99:23:99:50 | KeyDerivation | Salt | jca/Digest.java:97:66:97:69 | Salt | +| jca/Digest.java:109:23:109:57 | Digest | Source | jca/Digest.java:109:23:109:57 | Digest | +| jca/Digest.java:109:23:109:57 | HashOperation | Algorithm | jca/Digest.java:108:62:108:68 | HashAlgorithm | +| jca/Digest.java:109:23:109:57 | HashOperation | Digest | jca/Digest.java:109:23:109:57 | Digest | +| jca/Digest.java:109:23:109:57 | HashOperation | Message | jca/Digest.java:109:41:109:56 | Message | +| jca/Digest.java:109:41:109:56 | Message | Source | jca/Digest.java:107:40:107:51 | Parameter | +| jca/Digest.java:118:36:118:47 | KeyOperationAlgorithm | Mode | jca/Digest.java:118:36:118:47 | KeyOperationAlgorithm | +| jca/Digest.java:118:36:118:47 | KeyOperationAlgorithm | Padding | jca/Digest.java:118:36:118:47 | KeyOperationAlgorithm | +| jca/Digest.java:120:19:120:27 | Key | Source | jca/Digest.java:117:49:117:58 | Parameter | +| jca/Digest.java:121:23:121:52 | MACOperation | Algorithm | jca/Digest.java:118:36:118:47 | KeyOperationAlgorithm | +| jca/Digest.java:121:23:121:52 | MACOperation | HashAlgorithm | jca/Digest.java:121:23:121:52 | MACOperation | +| jca/Digest.java:121:23:121:52 | MACOperation | Input | jca/Digest.java:121:36:121:51 | Message | +| jca/Digest.java:121:23:121:52 | MACOperation | Key | jca/Digest.java:120:19:120:27 | Key | +| jca/Digest.java:121:23:121:52 | MACOperation | Message | jca/Digest.java:121:36:121:51 | Message | +| jca/Digest.java:121:23:121:52 | MACOperation | Nonce | jca/Digest.java:121:23:121:52 | MACOperation | +| jca/Digest.java:121:23:121:52 | MACOperation | Output | jca/Digest.java:121:23:121:52 | KeyOperationOutput | +| jca/Digest.java:121:36:121:51 | Message | Source | jca/Digest.java:117:35:117:46 | Parameter | +| jca/Digest.java:140:44:140:62 | KeyOperationAlgorithm | Mode | jca/Digest.java:140:44:140:62 | ModeOfOperation | +| jca/Digest.java:140:44:140:62 | KeyOperationAlgorithm | Padding | jca/Digest.java:140:44:140:62 | PaddingAlgorithm | +| jca/Digest.java:141:42:141:44 | Key | Source | jca/Digest.java:141:42:141:44 | Key | +| jca/Digest.java:142:32:142:74 | EncryptOperation | Algorithm | jca/Digest.java:140:44:140:62 | KeyOperationAlgorithm | +| jca/Digest.java:142:32:142:74 | EncryptOperation | Input | jca/Digest.java:142:47:142:73 | Message | +| jca/Digest.java:142:32:142:74 | EncryptOperation | Key | jca/Digest.java:141:42:141:44 | Key | +| jca/Digest.java:142:32:142:74 | EncryptOperation | Nonce | jca/Digest.java:142:32:142:74 | EncryptOperation | +| jca/Digest.java:142:32:142:74 | EncryptOperation | Output | jca/Digest.java:142:32:142:74 | KeyOperationOutput | +| jca/Digest.java:142:47:142:73 | Message | Source | jca/Digest.java:142:47:142:62 | Constant | +| jca/Digest.java:176:42:176:71 | Message | Source | jca/Digest.java:171:50:171:62 | Parameter | +| jca/Digest.java:176:74:176:77 | Salt | Source | jca/Digest.java:253:9:253:42 | RandomNumberGeneration | +| jca/Digest.java:176:74:176:77 | Salt | Source | jca/Digest.java:253:38:253:41 | RandomNumberGeneration | +| jca/Digest.java:177:65:177:86 | HMACAlgorithm | H | jca/Digest.java:177:65:177:86 | HashAlgorithm | +| jca/Digest.java:177:65:177:86 | KeyDerivationAlgorithm | PRF | jca/Digest.java:177:65:177:86 | HMACAlgorithm | +| jca/Digest.java:178:30:178:57 | KeyDerivation | Algorithm | jca/Digest.java:177:65:177:86 | KeyDerivationAlgorithm | +| jca/Digest.java:178:30:178:57 | KeyDerivation | Input | jca/Digest.java:176:42:176:71 | Message | +| jca/Digest.java:178:30:178:57 | KeyDerivation | Output | jca/Digest.java:178:30:178:57 | Key | +| jca/Digest.java:178:30:178:57 | KeyDerivation | Salt | jca/Digest.java:176:74:176:77 | Salt | +| jca/Digest.java:186:44:186:62 | KeyOperationAlgorithm | Mode | jca/Digest.java:186:44:186:62 | ModeOfOperation | +| jca/Digest.java:186:44:186:62 | KeyOperationAlgorithm | Padding | jca/Digest.java:186:44:186:62 | PaddingAlgorithm | +| jca/Digest.java:187:42:187:54 | Key | Source | jca/Digest.java:187:42:187:54 | Key | +| jca/Digest.java:188:29:188:78 | EncryptOperation | Algorithm | jca/Digest.java:186:44:186:62 | KeyOperationAlgorithm | +| jca/Digest.java:188:29:188:78 | EncryptOperation | Input | jca/Digest.java:188:44:188:77 | Message | +| jca/Digest.java:188:29:188:78 | EncryptOperation | Key | jca/Digest.java:187:42:187:54 | Key | +| jca/Digest.java:188:29:188:78 | EncryptOperation | Nonce | jca/Digest.java:188:29:188:78 | EncryptOperation | +| jca/Digest.java:188:29:188:78 | EncryptOperation | Output | jca/Digest.java:188:29:188:78 | KeyOperationOutput | +| jca/Digest.java:188:44:188:77 | Message | Source | jca/Digest.java:188:44:188:66 | Constant | +| jca/Digest.java:191:35:191:46 | KeyOperationAlgorithm | Mode | jca/Digest.java:191:35:191:46 | KeyOperationAlgorithm | +| jca/Digest.java:191:35:191:46 | KeyOperationAlgorithm | Padding | jca/Digest.java:191:35:191:46 | KeyOperationAlgorithm | +| jca/Digest.java:192:18:192:23 | Key | Source | jca/Digest.java:192:18:192:23 | Key | +| jca/Digest.java:193:30:193:52 | MACOperation | Algorithm | jca/Digest.java:191:35:191:46 | KeyOperationAlgorithm | +| jca/Digest.java:193:30:193:52 | MACOperation | HashAlgorithm | jca/Digest.java:193:30:193:52 | MACOperation | +| jca/Digest.java:193:30:193:52 | MACOperation | Input | jca/Digest.java:193:42:193:51 | Message | +| jca/Digest.java:193:30:193:52 | MACOperation | Key | jca/Digest.java:192:18:192:23 | Key | +| jca/Digest.java:193:30:193:52 | MACOperation | Message | jca/Digest.java:193:42:193:51 | Message | +| jca/Digest.java:193:30:193:52 | MACOperation | Nonce | jca/Digest.java:193:30:193:52 | MACOperation | +| jca/Digest.java:193:30:193:52 | MACOperation | Output | jca/Digest.java:193:30:193:52 | KeyOperationOutput | +| jca/Digest.java:193:42:193:51 | Message | Source | jca/Digest.java:188:29:188:78 | KeyOperationOutput | +| jca/Digest.java:210:44:210:62 | KeyOperationAlgorithm | Mode | jca/Digest.java:210:44:210:62 | ModeOfOperation | +| jca/Digest.java:210:44:210:62 | KeyOperationAlgorithm | Padding | jca/Digest.java:210:44:210:62 | PaddingAlgorithm | +| jca/Digest.java:212:42:212:44 | Key | Source | jca/Digest.java:241:16:241:35 | Key | +| jca/Digest.java:213:32:213:51 | EncryptOperation | Algorithm | jca/Digest.java:210:44:210:62 | KeyOperationAlgorithm | +| jca/Digest.java:213:32:213:51 | EncryptOperation | Input | jca/Digest.java:213:47:213:50 | Message | +| jca/Digest.java:213:32:213:51 | EncryptOperation | Key | jca/Digest.java:212:42:212:44 | Key | +| jca/Digest.java:213:32:213:51 | EncryptOperation | Nonce | jca/Digest.java:213:32:213:51 | EncryptOperation | +| jca/Digest.java:213:32:213:51 | EncryptOperation | Output | jca/Digest.java:213:32:213:51 | KeyOperationOutput | +| jca/Digest.java:213:47:213:50 | Message | Source | jca/Digest.java:155:39:155:51 | Parameter | +| jca/Digest.java:241:16:241:35 | KeyGeneration | Algorithm | jca/Digest.java:239:56:239:60 | KeyOperationAlgorithm | +| jca/Digest.java:241:16:241:35 | KeyGeneration | Output | jca/Digest.java:241:16:241:35 | Key | +| jca/EllipticCurve1.java:47:16:47:36 | Key | Algorithm | jca/EllipticCurve1.java:46:66:46:76 | EllipticCurve | +| jca/EllipticCurve1.java:47:16:47:36 | KeyGeneration | Algorithm | jca/EllipticCurve1.java:46:66:46:76 | EllipticCurve | +| jca/EllipticCurve1.java:47:16:47:36 | KeyGeneration | Output | jca/EllipticCurve1.java:47:16:47:36 | Key | +| jca/EllipticCurve1.java:57:16:57:36 | Key | Algorithm | jca/EllipticCurve1.java:56:66:56:76 | EllipticCurve | +| jca/EllipticCurve1.java:57:16:57:36 | KeyGeneration | Algorithm | jca/EllipticCurve1.java:56:66:56:76 | EllipticCurve | +| jca/EllipticCurve1.java:57:16:57:36 | KeyGeneration | Output | jca/EllipticCurve1.java:57:16:57:36 | Key | +| jca/EllipticCurve1.java:67:16:67:36 | Key | Algorithm | jca/EllipticCurve1.java:66:66:66:82 | EllipticCurve | +| jca/EllipticCurve1.java:67:16:67:36 | KeyGeneration | Algorithm | jca/EllipticCurve1.java:66:66:66:82 | EllipticCurve | +| jca/EllipticCurve1.java:67:16:67:36 | KeyGeneration | Output | jca/EllipticCurve1.java:67:16:67:36 | Key | +| jca/EllipticCurve1.java:76:16:76:36 | Key | Algorithm | jca/EllipticCurve1.java:74:61:74:68 | KeyAgreementAlgorithm | +| jca/EllipticCurve1.java:76:16:76:36 | KeyGeneration | Algorithm | jca/EllipticCurve1.java:74:61:74:68 | KeyAgreementAlgorithm | +| jca/EllipticCurve1.java:76:16:76:36 | KeyGeneration | Output | jca/EllipticCurve1.java:76:16:76:36 | Key | +| jca/EllipticCurve1.java:84:16:84:36 | Key | Algorithm | jca/EllipticCurve1.java:83:61:83:66 | KeyAgreementAlgorithm | +| jca/EllipticCurve1.java:84:16:84:36 | KeyGeneration | Algorithm | jca/EllipticCurve1.java:83:61:83:66 | KeyAgreementAlgorithm | +| jca/EllipticCurve1.java:84:16:84:36 | KeyGeneration | Output | jca/EllipticCurve1.java:84:16:84:36 | Key | +| jca/EllipticCurve1.java:95:16:95:36 | Key | Algorithm | jca/EllipticCurve1.java:94:66:94:76 | EllipticCurve | +| jca/EllipticCurve1.java:95:16:95:36 | KeyGeneration | Algorithm | jca/EllipticCurve1.java:94:66:94:76 | EllipticCurve | +| jca/EllipticCurve1.java:95:16:95:36 | KeyGeneration | Output | jca/EllipticCurve1.java:95:16:95:36 | Key | +| jca/EllipticCurve1.java:106:16:106:36 | Key | Algorithm | jca/EllipticCurve1.java:105:66:105:76 | Constant | +| jca/EllipticCurve1.java:106:16:106:36 | KeyGeneration | Algorithm | jca/EllipticCurve1.java:105:66:105:76 | Constant | +| jca/EllipticCurve1.java:106:16:106:36 | KeyGeneration | Output | jca/EllipticCurve1.java:106:16:106:36 | Key | +| jca/EllipticCurve1.java:115:16:115:36 | Key | Algorithm | jca/EllipticCurve1.java:114:61:114:69 | Constant | +| jca/EllipticCurve1.java:115:16:115:36 | KeyGeneration | Algorithm | jca/EllipticCurve1.java:114:61:114:69 | Constant | +| jca/EllipticCurve1.java:115:16:115:36 | KeyGeneration | Output | jca/EllipticCurve1.java:115:16:115:36 | Key | +| jca/EllipticCurve2.java:47:16:47:36 | Key | Algorithm | jca/EllipticCurve2.java:46:47:46:57 | EllipticCurve | +| jca/EllipticCurve2.java:47:16:47:36 | KeyGeneration | Algorithm | jca/EllipticCurve2.java:46:47:46:57 | EllipticCurve | +| jca/EllipticCurve2.java:47:16:47:36 | KeyGeneration | Output | jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:56:16:56:36 | Key | Algorithm | jca/EllipticCurve2.java:55:47:55:57 | EllipticCurve | +| jca/EllipticCurve2.java:56:16:56:36 | KeyGeneration | Algorithm | jca/EllipticCurve2.java:55:47:55:57 | EllipticCurve | +| jca/EllipticCurve2.java:56:16:56:36 | KeyGeneration | Output | jca/EllipticCurve2.java:56:16:56:36 | Key | +| jca/EllipticCurve2.java:65:16:65:36 | Key | Algorithm | jca/EllipticCurve2.java:64:47:64:63 | EllipticCurve | +| jca/EllipticCurve2.java:65:16:65:36 | KeyGeneration | Algorithm | jca/EllipticCurve2.java:64:47:64:63 | EllipticCurve | +| jca/EllipticCurve2.java:65:16:65:36 | KeyGeneration | Output | jca/EllipticCurve2.java:65:16:65:36 | Key | +| jca/EllipticCurve2.java:73:16:73:36 | Key | Algorithm | jca/EllipticCurve2.java:72:61:72:68 | KeyAgreementAlgorithm | +| jca/EllipticCurve2.java:73:16:73:36 | KeyGeneration | Algorithm | jca/EllipticCurve2.java:72:61:72:68 | KeyAgreementAlgorithm | +| jca/EllipticCurve2.java:73:16:73:36 | KeyGeneration | Output | jca/EllipticCurve2.java:73:16:73:36 | Key | +| jca/EllipticCurve2.java:81:16:81:36 | Key | Algorithm | jca/EllipticCurve2.java:80:61:80:69 | Constant | +| jca/EllipticCurve2.java:81:16:81:36 | KeyGeneration | Algorithm | jca/EllipticCurve2.java:80:61:80:69 | Constant | +| jca/EllipticCurve2.java:81:16:81:36 | KeyGeneration | Output | jca/EllipticCurve2.java:81:16:81:36 | Key | +| jca/EllipticCurve2.java:106:17:106:36 | Key | Source | jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:107:20:107:36 | Key | Source | jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:108:16:108:34 | KeyAgreementOperation | Algorithm | jca/EllipticCurve2.java:105:52:105:57 | KeyAgreementAlgorithm | +| jca/EllipticCurve2.java:108:16:108:34 | KeyAgreementOperation | Output | jca/EllipticCurve2.java:108:16:108:34 | SharedSecret | +| jca/EllipticCurve2.java:108:16:108:34 | KeyAgreementOperation | PeerKey | jca/EllipticCurve2.java:107:20:107:36 | Key | +| jca/EllipticCurve2.java:108:16:108:34 | KeyAgreementOperation | ServerKey | jca/EllipticCurve2.java:106:17:106:36 | Key | +| jca/EllipticCurve2.java:108:16:108:34 | SharedSecret | Source | jca/EllipticCurve2.java:108:16:108:34 | SharedSecret | +| jca/EllipticCurve2.java:120:17:120:37 | Key | Source | jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:121:20:121:39 | Key | Source | jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:122:16:122:34 | KeyAgreementOperation | Algorithm | jca/EllipticCurve2.java:119:52:119:57 | KeyAgreementAlgorithm | +| jca/EllipticCurve2.java:122:16:122:34 | KeyAgreementOperation | Output | jca/EllipticCurve2.java:122:16:122:34 | SharedSecret | +| jca/EllipticCurve2.java:122:16:122:34 | KeyAgreementOperation | PeerKey | jca/EllipticCurve2.java:121:20:121:39 | Key | +| jca/EllipticCurve2.java:122:16:122:34 | KeyAgreementOperation | ServerKey | jca/EllipticCurve2.java:120:17:120:37 | Key | +| jca/EllipticCurve2.java:122:16:122:34 | SharedSecret | Source | jca/EllipticCurve2.java:122:16:122:34 | SharedSecret | +| jca/EllipticCurve2.java:136:53:136:69 | KeyOperationAlgorithm | Mode | jca/EllipticCurve2.java:136:53:136:69 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:136:53:136:69 | KeyOperationAlgorithm | Padding | jca/EllipticCurve2.java:136:53:136:69 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:137:28:137:42 | Key | Source | jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:138:26:138:32 | Message | Source | jca/EllipticCurve2.java:245:30:245:53 | Constant | +| jca/EllipticCurve2.java:139:16:139:31 | SignOperation | Algorithm | jca/EllipticCurve2.java:136:53:136:69 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:139:16:139:31 | SignOperation | HashAlgorithm | jca/EllipticCurve2.java:136:53:136:69 | HashAlgorithm | +| jca/EllipticCurve2.java:139:16:139:31 | SignOperation | Input | jca/EllipticCurve2.java:138:26:138:32 | Message | +| jca/EllipticCurve2.java:139:16:139:31 | SignOperation | Key | jca/EllipticCurve2.java:137:28:137:42 | Key | +| jca/EllipticCurve2.java:139:16:139:31 | SignOperation | Output | jca/EllipticCurve2.java:139:16:139:31 | SignatureOutput | +| jca/EllipticCurve2.java:151:53:151:69 | KeyOperationAlgorithm | Mode | jca/EllipticCurve2.java:151:53:151:69 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:151:53:151:69 | KeyOperationAlgorithm | Padding | jca/EllipticCurve2.java:151:53:151:69 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:152:30:152:43 | Key | Source | jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:153:26:153:32 | Message | Source | jca/EllipticCurve2.java:245:30:245:53 | Constant | +| jca/EllipticCurve2.java:154:16:154:47 | VerifyOperation | Algorithm | jca/EllipticCurve2.java:151:53:151:69 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:154:16:154:47 | VerifyOperation | HashAlgorithm | jca/EllipticCurve2.java:151:53:151:69 | HashAlgorithm | +| jca/EllipticCurve2.java:154:16:154:47 | VerifyOperation | Input | jca/EllipticCurve2.java:153:26:153:32 | Message | +| jca/EllipticCurve2.java:154:16:154:47 | VerifyOperation | Key | jca/EllipticCurve2.java:152:30:152:43 | Key | +| jca/EllipticCurve2.java:154:16:154:47 | VerifyOperation | Signature | jca/EllipticCurve2.java:154:33:154:46 | SignatureInput | +| jca/EllipticCurve2.java:154:33:154:46 | SignatureInput | Source | jca/EllipticCurve2.java:139:16:139:31 | SignatureOutput | +| jca/EllipticCurve2.java:166:53:166:61 | KeyOperationAlgorithm | Mode | jca/EllipticCurve2.java:166:53:166:61 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:166:53:166:61 | KeyOperationAlgorithm | Padding | jca/EllipticCurve2.java:166:53:166:61 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:167:28:167:42 | Key | Source | jca/EllipticCurve2.java:81:16:81:36 | Key | +| jca/EllipticCurve2.java:168:26:168:32 | Message | Source | jca/EllipticCurve2.java:245:30:245:53 | Constant | +| jca/EllipticCurve2.java:169:16:169:31 | SignOperation | Algorithm | jca/EllipticCurve2.java:166:53:166:61 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:169:16:169:31 | SignOperation | HashAlgorithm | jca/EllipticCurve2.java:169:16:169:31 | SignOperation | +| jca/EllipticCurve2.java:169:16:169:31 | SignOperation | Input | jca/EllipticCurve2.java:168:26:168:32 | Message | +| jca/EllipticCurve2.java:169:16:169:31 | SignOperation | Key | jca/EllipticCurve2.java:167:28:167:42 | Key | +| jca/EllipticCurve2.java:169:16:169:31 | SignOperation | Output | jca/EllipticCurve2.java:169:16:169:31 | SignatureOutput | +| jca/EllipticCurve2.java:181:53:181:61 | KeyOperationAlgorithm | Mode | jca/EllipticCurve2.java:181:53:181:61 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:181:53:181:61 | KeyOperationAlgorithm | Padding | jca/EllipticCurve2.java:181:53:181:61 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:182:30:182:43 | Key | Source | jca/EllipticCurve2.java:81:16:81:36 | Key | +| jca/EllipticCurve2.java:183:26:183:32 | Message | Source | jca/EllipticCurve2.java:245:30:245:53 | Constant | +| jca/EllipticCurve2.java:184:16:184:47 | VerifyOperation | Algorithm | jca/EllipticCurve2.java:181:53:181:61 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:184:16:184:47 | VerifyOperation | HashAlgorithm | jca/EllipticCurve2.java:184:16:184:47 | VerifyOperation | +| jca/EllipticCurve2.java:184:16:184:47 | VerifyOperation | Input | jca/EllipticCurve2.java:183:26:183:32 | Message | +| jca/EllipticCurve2.java:184:16:184:47 | VerifyOperation | Key | jca/EllipticCurve2.java:182:30:182:43 | Key | +| jca/EllipticCurve2.java:184:16:184:47 | VerifyOperation | Signature | jca/EllipticCurve2.java:184:33:184:46 | SignatureInput | +| jca/EllipticCurve2.java:184:33:184:46 | SignatureInput | Source | jca/EllipticCurve2.java:169:16:169:31 | SignatureOutput | +| jca/EllipticCurve2.java:207:17:207:37 | Key | Source | jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:208:20:208:41 | Key | Source | jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:209:31:209:49 | KeyAgreementOperation | Algorithm | jca/EllipticCurve2.java:206:52:206:57 | KeyAgreementAlgorithm | +| jca/EllipticCurve2.java:209:31:209:49 | KeyAgreementOperation | Output | jca/EllipticCurve2.java:209:31:209:49 | SharedSecret | +| jca/EllipticCurve2.java:209:31:209:49 | KeyAgreementOperation | PeerKey | jca/EllipticCurve2.java:208:20:208:41 | Key | +| jca/EllipticCurve2.java:209:31:209:49 | KeyAgreementOperation | ServerKey | jca/EllipticCurve2.java:207:17:207:37 | Key | +| jca/EllipticCurve2.java:209:31:209:49 | SharedSecret | Source | jca/EllipticCurve2.java:209:31:209:49 | SharedSecret | +| jca/EllipticCurve2.java:214:29:214:55 | Digest | Source | jca/EllipticCurve2.java:214:29:214:55 | Digest | +| jca/EllipticCurve2.java:214:29:214:55 | HashOperation | Algorithm | jca/EllipticCurve2.java:213:58:213:66 | HashAlgorithm | +| jca/EllipticCurve2.java:214:29:214:55 | HashOperation | Digest | jca/EllipticCurve2.java:214:29:214:55 | Digest | +| jca/EllipticCurve2.java:214:29:214:55 | HashOperation | Message | jca/EllipticCurve2.java:214:43:214:54 | Message | +| jca/EllipticCurve2.java:214:43:214:54 | Message | Source | jca/EllipticCurve2.java:209:31:209:49 | SharedSecret | +| jca/EllipticCurve2.java:219:44:219:62 | KeyOperationAlgorithm | Mode | jca/EllipticCurve2.java:219:44:219:62 | ModeOfOperation | +| jca/EllipticCurve2.java:219:44:219:62 | KeyOperationAlgorithm | Padding | jca/EllipticCurve2.java:219:44:219:62 | PaddingAlgorithm | +| jca/EllipticCurve2.java:223:42:223:47 | Key | Source | jca/EllipticCurve2.java:223:42:223:47 | Key | +| jca/EllipticCurve2.java:223:50:223:53 | Nonce | Source | jca/EllipticCurve2.java:221:9:221:40 | RandomNumberGeneration | +| jca/EllipticCurve2.java:223:50:223:53 | Nonce | Source | jca/EllipticCurve2.java:221:38:221:39 | RandomNumberGeneration | +| jca/EllipticCurve2.java:224:29:224:53 | EncryptOperation | Algorithm | jca/EllipticCurve2.java:219:44:219:62 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:224:29:224:53 | EncryptOperation | Input | jca/EllipticCurve2.java:224:44:224:52 | Message | +| jca/EllipticCurve2.java:224:29:224:53 | EncryptOperation | Key | jca/EllipticCurve2.java:223:42:223:47 | Key | +| jca/EllipticCurve2.java:224:29:224:53 | EncryptOperation | Nonce | jca/EllipticCurve2.java:223:50:223:53 | Nonce | +| jca/EllipticCurve2.java:224:29:224:53 | EncryptOperation | Output | jca/EllipticCurve2.java:224:29:224:53 | KeyOperationOutput | +| jca/EllipticCurve2.java:224:44:224:52 | Message | Source | jca/EllipticCurve2.java:258:62:258:83 | Constant | +| jca/Encryption1.java:62:25:62:44 | KeyGeneration | Algorithm | jca/Encryption1.java:60:56:60:60 | KeyOperationAlgorithm | +| jca/Encryption1.java:62:25:62:44 | KeyGeneration | Output | jca/Encryption1.java:62:25:62:44 | Key | +| jca/Encryption1.java:63:44:63:62 | KeyOperationAlgorithm | Mode | jca/Encryption1.java:63:44:63:62 | ModeOfOperation | +| jca/Encryption1.java:63:44:63:62 | KeyOperationAlgorithm | Padding | jca/Encryption1.java:63:44:63:62 | PaddingAlgorithm | +| jca/Encryption1.java:67:42:67:44 | Key | Source | jca/Encryption1.java:62:25:62:44 | Key | +| jca/Encryption1.java:67:47:67:53 | Nonce | Source | jca/Encryption1.java:65:9:65:40 | RandomNumberGeneration | +| jca/Encryption1.java:67:47:67:53 | Nonce | Source | jca/Encryption1.java:65:38:65:39 | RandomNumberGeneration | +| jca/Encryption1.java:68:32:68:74 | EncryptOperation | Algorithm | jca/Encryption1.java:63:44:63:62 | KeyOperationAlgorithm | +| jca/Encryption1.java:68:32:68:74 | EncryptOperation | Input | jca/Encryption1.java:68:47:68:73 | Message | +| jca/Encryption1.java:68:32:68:74 | EncryptOperation | Key | jca/Encryption1.java:67:42:67:44 | Key | +| jca/Encryption1.java:68:32:68:74 | EncryptOperation | Nonce | jca/Encryption1.java:67:47:67:53 | Nonce | +| jca/Encryption1.java:68:32:68:74 | EncryptOperation | Output | jca/Encryption1.java:68:32:68:74 | KeyOperationOutput | +| jca/Encryption1.java:68:47:68:73 | Message | Source | jca/Encryption1.java:68:47:68:62 | Constant | +| jca/Encryption1.java:85:25:85:44 | KeyGeneration | Algorithm | jca/Encryption1.java:83:56:83:60 | KeyOperationAlgorithm | +| jca/Encryption1.java:85:25:85:44 | KeyGeneration | Output | jca/Encryption1.java:85:25:85:44 | Key | +| jca/Encryption1.java:88:44:88:62 | KeyOperationAlgorithm | Mode | jca/Encryption1.java:88:44:88:62 | ModeOfOperation | +| jca/Encryption1.java:88:44:88:62 | KeyOperationAlgorithm | Padding | jca/Encryption1.java:88:44:88:62 | PaddingAlgorithm | +| jca/Encryption1.java:89:42:89:44 | Key | Source | jca/Encryption1.java:85:25:85:44 | Key | +| jca/Encryption1.java:90:32:90:74 | EncryptOperation | Algorithm | jca/Encryption1.java:88:44:88:62 | KeyOperationAlgorithm | +| jca/Encryption1.java:90:32:90:74 | EncryptOperation | Input | jca/Encryption1.java:90:47:90:73 | Message | +| jca/Encryption1.java:90:32:90:74 | EncryptOperation | Key | jca/Encryption1.java:89:42:89:44 | Key | +| jca/Encryption1.java:90:32:90:74 | EncryptOperation | Nonce | jca/Encryption1.java:90:32:90:74 | EncryptOperation | +| jca/Encryption1.java:90:32:90:74 | EncryptOperation | Output | jca/Encryption1.java:90:32:90:74 | KeyOperationOutput | +| jca/Encryption1.java:90:47:90:73 | Message | Source | jca/Encryption1.java:90:47:90:62 | Constant | +| jca/Encryption1.java:105:44:105:82 | KeyOperationAlgorithm | Mode | jca/Encryption1.java:105:44:105:82 | ModeOfOperation | +| jca/Encryption1.java:105:44:105:82 | KeyOperationAlgorithm | Padding | jca/Encryption1.java:105:44:105:82 | PaddingAlgorithm | +| jca/Encryption1.java:105:44:105:82 | PaddingAlgorithm | MD | jca/Encryption1.java:105:44:105:82 | HashAlgorithm | +| jca/Encryption1.java:105:44:105:82 | PaddingAlgorithm | MGF1Hash | jca/Encryption1.java:105:44:105:82 | PaddingAlgorithm | +| jca/Encryption1.java:106:42:106:50 | Key | Source | jca/Encryption1.java:104:35:104:53 | Parameter | +| jca/Encryption1.java:107:32:107:62 | EncryptOperation | Algorithm | jca/Encryption1.java:105:44:105:82 | KeyOperationAlgorithm | +| jca/Encryption1.java:107:32:107:62 | EncryptOperation | Input | jca/Encryption1.java:107:47:107:61 | Message | +| jca/Encryption1.java:107:32:107:62 | EncryptOperation | Key | jca/Encryption1.java:106:42:106:50 | Key | +| jca/Encryption1.java:107:32:107:62 | EncryptOperation | Nonce | jca/Encryption1.java:107:32:107:62 | EncryptOperation | +| jca/Encryption1.java:107:32:107:62 | EncryptOperation | Output | jca/Encryption1.java:107:32:107:62 | KeyOperationOutput | +| jca/Encryption1.java:107:47:107:61 | Message | Source | jca/Encryption1.java:104:56:104:66 | Parameter | +| jca/Encryption1.java:120:44:120:82 | KeyOperationAlgorithm | Mode | jca/Encryption1.java:120:44:120:82 | ModeOfOperation | +| jca/Encryption1.java:120:44:120:82 | KeyOperationAlgorithm | Padding | jca/Encryption1.java:120:44:120:82 | PaddingAlgorithm | +| jca/Encryption1.java:120:44:120:82 | PaddingAlgorithm | MD | jca/Encryption1.java:120:44:120:82 | HashAlgorithm | +| jca/Encryption1.java:120:44:120:82 | PaddingAlgorithm | MGF1Hash | jca/Encryption1.java:120:44:120:82 | PaddingAlgorithm | +| jca/Encryption1.java:121:42:121:51 | Key | Source | jca/Encryption1.java:119:35:119:55 | Parameter | +| jca/Encryption1.java:122:32:122:60 | DecryptOperation | Algorithm | jca/Encryption1.java:120:44:120:82 | KeyOperationAlgorithm | +| jca/Encryption1.java:122:32:122:60 | DecryptOperation | Input | jca/Encryption1.java:122:47:122:59 | Message | +| jca/Encryption1.java:122:32:122:60 | DecryptOperation | Key | jca/Encryption1.java:121:42:121:51 | Key | +| jca/Encryption1.java:122:32:122:60 | DecryptOperation | Nonce | jca/Encryption1.java:122:32:122:60 | DecryptOperation | +| jca/Encryption1.java:122:32:122:60 | DecryptOperation | Output | jca/Encryption1.java:122:32:122:60 | KeyOperationOutput | +| jca/Encryption1.java:122:47:122:59 | Message | Source | jca/Encryption1.java:119:58:119:77 | Parameter | +| jca/Encryption1.java:139:28:139:47 | KeyGeneration | Algorithm | jca/Encryption1.java:137:56:137:60 | KeyOperationAlgorithm | +| jca/Encryption1.java:139:28:139:47 | KeyGeneration | Output | jca/Encryption1.java:139:28:139:47 | Key | +| jca/Encryption1.java:141:47:141:85 | KeyOperationAlgorithm | Mode | jca/Encryption1.java:141:47:141:85 | ModeOfOperation | +| jca/Encryption1.java:141:47:141:85 | KeyOperationAlgorithm | Padding | jca/Encryption1.java:141:47:141:85 | PaddingAlgorithm | +| jca/Encryption1.java:141:47:141:85 | PaddingAlgorithm | MD | jca/Encryption1.java:141:47:141:85 | HashAlgorithm | +| jca/Encryption1.java:141:47:141:85 | PaddingAlgorithm | MGF1Hash | jca/Encryption1.java:141:47:141:85 | PaddingAlgorithm | +| jca/Encryption1.java:142:45:142:56 | Key | Source | jca/Encryption1.java:136:34:136:55 | Parameter | +| jca/Encryption1.java:143:34:143:71 | EncryptOperation | Algorithm | jca/Encryption1.java:141:47:141:85 | KeyOperationAlgorithm | +| jca/Encryption1.java:143:34:143:71 | EncryptOperation | Input | jca/Encryption1.java:143:52:143:70 | Message | +| jca/Encryption1.java:143:34:143:71 | EncryptOperation | Key | jca/Encryption1.java:142:45:142:56 | Key | +| jca/Encryption1.java:143:34:143:71 | EncryptOperation | Nonce | jca/Encryption1.java:143:34:143:71 | EncryptOperation | +| jca/Encryption1.java:143:34:143:71 | EncryptOperation | Output | jca/Encryption1.java:143:34:143:71 | KeyOperationOutput | +| jca/Encryption1.java:143:52:143:70 | Message | Source | jca/Encryption1.java:139:28:139:47 | Key | +| jca/Encryption1.java:163:28:163:47 | KeyGeneration | Algorithm | jca/Encryption1.java:161:56:161:60 | KeyOperationAlgorithm | +| jca/Encryption1.java:163:28:163:47 | KeyGeneration | Output | jca/Encryption1.java:163:28:163:47 | Key | +| jca/Encryption1.java:166:47:166:85 | KeyOperationAlgorithm | Mode | jca/Encryption1.java:166:47:166:85 | ModeOfOperation | +| jca/Encryption1.java:166:47:166:85 | KeyOperationAlgorithm | Padding | jca/Encryption1.java:166:47:166:85 | PaddingAlgorithm | +| jca/Encryption1.java:166:47:166:85 | PaddingAlgorithm | MD | jca/Encryption1.java:166:47:166:85 | HashAlgorithm | +| jca/Encryption1.java:166:47:166:85 | PaddingAlgorithm | MGF1Hash | jca/Encryption1.java:166:47:166:85 | PaddingAlgorithm | +| jca/Encryption1.java:167:45:167:56 | Key | Source | jca/Encryption1.java:159:34:159:55 | Parameter | +| jca/Encryption1.java:168:34:168:71 | EncryptOperation | Algorithm | jca/Encryption1.java:166:47:166:85 | KeyOperationAlgorithm | +| jca/Encryption1.java:168:34:168:71 | EncryptOperation | Input | jca/Encryption1.java:168:52:168:70 | Message | +| jca/Encryption1.java:168:34:168:71 | EncryptOperation | Key | jca/Encryption1.java:167:45:167:56 | Key | +| jca/Encryption1.java:168:34:168:71 | EncryptOperation | Nonce | jca/Encryption1.java:168:34:168:71 | EncryptOperation | +| jca/Encryption1.java:168:34:168:71 | EncryptOperation | Output | jca/Encryption1.java:168:34:168:71 | KeyOperationOutput | +| jca/Encryption1.java:168:52:168:70 | Message | Source | jca/Encryption1.java:163:28:163:47 | Key | +| jca/Encryption1.java:171:47:171:65 | KeyOperationAlgorithm | Mode | jca/Encryption1.java:171:47:171:65 | ModeOfOperation | +| jca/Encryption1.java:171:47:171:65 | KeyOperationAlgorithm | Padding | jca/Encryption1.java:171:47:171:65 | PaddingAlgorithm | +| jca/Encryption1.java:175:45:175:50 | Key | Source | jca/Encryption1.java:163:28:163:47 | Key | +| jca/Encryption1.java:175:53:175:59 | Nonce | Source | jca/Encryption1.java:173:9:173:40 | RandomNumberGeneration | +| jca/Encryption1.java:175:53:175:59 | Nonce | Source | jca/Encryption1.java:173:38:173:39 | RandomNumberGeneration | +| jca/Encryption1.java:176:32:176:65 | EncryptOperation | Algorithm | jca/Encryption1.java:171:47:171:65 | KeyOperationAlgorithm | +| jca/Encryption1.java:176:32:176:65 | EncryptOperation | Input | jca/Encryption1.java:176:50:176:64 | Message | +| jca/Encryption1.java:176:32:176:65 | EncryptOperation | Key | jca/Encryption1.java:175:45:175:50 | Key | +| jca/Encryption1.java:176:32:176:65 | EncryptOperation | Nonce | jca/Encryption1.java:175:53:175:59 | Nonce | +| jca/Encryption1.java:176:32:176:65 | EncryptOperation | Output | jca/Encryption1.java:176:32:176:65 | KeyOperationOutput | +| jca/Encryption1.java:176:50:176:64 | Message | Source | jca/Encryption1.java:159:58:159:68 | Parameter | +| jca/Encryption2.java:56:16:56:49 | Key | Algorithm | jca/Encryption2.java:55:60:55:70 | EllipticCurve | +| jca/Encryption2.java:56:16:56:49 | KeyGeneration | Algorithm | jca/Encryption2.java:55:60:55:70 | EllipticCurve | +| jca/Encryption2.java:56:16:56:49 | KeyGeneration | Output | jca/Encryption2.java:56:16:56:49 | Key | +| jca/Encryption2.java:72:27:72:36 | Key | Source | jca/Encryption2.java:56:16:56:49 | Key | +| jca/Encryption2.java:73:30:73:38 | Key | Source | jca/Encryption2.java:90:38:90:65 | Parameter | +| jca/Encryption2.java:73:30:73:38 | Key | Source | jca/Encryption2.java:132:45:132:65 | Parameter | +| jca/Encryption2.java:74:16:74:44 | KeyAgreementOperation | Algorithm | jca/Encryption2.java:71:62:71:67 | KeyAgreementAlgorithm | +| jca/Encryption2.java:74:16:74:44 | KeyAgreementOperation | Output | jca/Encryption2.java:74:16:74:44 | SharedSecret | +| jca/Encryption2.java:74:16:74:44 | KeyAgreementOperation | PeerKey | jca/Encryption2.java:73:30:73:38 | Key | +| jca/Encryption2.java:74:16:74:44 | KeyAgreementOperation | ServerKey | jca/Encryption2.java:72:27:72:36 | Key | +| jca/Encryption2.java:74:16:74:44 | SharedSecret | Source | jca/Encryption2.java:74:16:74:44 | SharedSecret | +| jca/Encryption2.java:100:30:100:56 | Digest | Source | jca/Encryption2.java:100:30:100:56 | Digest | +| jca/Encryption2.java:100:30:100:56 | HashOperation | Algorithm | jca/Encryption2.java:99:58:99:66 | HashAlgorithm | +| jca/Encryption2.java:100:30:100:56 | HashOperation | Digest | jca/Encryption2.java:100:30:100:56 | Digest | +| jca/Encryption2.java:100:30:100:56 | HashOperation | Message | jca/Encryption2.java:100:44:100:55 | Message | +| jca/Encryption2.java:100:44:100:55 | Message | Source | jca/Encryption2.java:74:16:74:44 | SharedSecret | +| jca/Encryption2.java:105:47:105:65 | KeyOperationAlgorithm | Mode | jca/Encryption2.java:105:47:105:65 | ModeOfOperation | +| jca/Encryption2.java:105:47:105:65 | KeyOperationAlgorithm | Padding | jca/Encryption2.java:105:47:105:65 | PaddingAlgorithm | +| jca/Encryption2.java:109:45:109:50 | Key | Source | jca/Encryption2.java:109:45:109:50 | Key | +| jca/Encryption2.java:109:53:109:59 | Nonce | Source | jca/Encryption2.java:107:9:107:40 | RandomNumberGeneration | +| jca/Encryption2.java:109:53:109:59 | Nonce | Source | jca/Encryption2.java:107:38:107:39 | RandomNumberGeneration | +| jca/Encryption2.java:110:32:110:65 | EncryptOperation | Algorithm | jca/Encryption2.java:105:47:105:65 | KeyOperationAlgorithm | +| jca/Encryption2.java:110:32:110:65 | EncryptOperation | Input | jca/Encryption2.java:110:50:110:64 | Message | +| jca/Encryption2.java:110:32:110:65 | EncryptOperation | Key | jca/Encryption2.java:109:45:109:50 | Key | +| jca/Encryption2.java:110:32:110:65 | EncryptOperation | Nonce | jca/Encryption2.java:109:53:109:59 | Nonce | +| jca/Encryption2.java:110:32:110:65 | EncryptOperation | Output | jca/Encryption2.java:110:32:110:65 | KeyOperationOutput | +| jca/Encryption2.java:110:50:110:64 | Message | Source | jca/Encryption2.java:90:68:90:78 | Parameter | +| jca/Encryption2.java:145:47:145:65 | KeyOperationAlgorithm | Mode | jca/Encryption2.java:145:47:145:65 | ModeOfOperation | +| jca/Encryption2.java:145:47:145:65 | KeyOperationAlgorithm | Padding | jca/Encryption2.java:145:47:145:65 | PaddingAlgorithm | +| jca/Encryption2.java:149:45:149:50 | Key | Source | jca/Encryption2.java:149:45:149:50 | Key | +| jca/Encryption2.java:149:53:149:59 | Nonce | Source | jca/Encryption2.java:147:9:147:40 | RandomNumberGeneration | +| jca/Encryption2.java:149:53:149:59 | Nonce | Source | jca/Encryption2.java:147:38:147:39 | RandomNumberGeneration | +| jca/Encryption2.java:150:32:150:98 | EncryptOperation | Algorithm | jca/Encryption2.java:145:47:145:65 | KeyOperationAlgorithm | +| jca/Encryption2.java:150:32:150:98 | EncryptOperation | Input | jca/Encryption2.java:150:50:150:97 | Message | +| jca/Encryption2.java:150:32:150:98 | EncryptOperation | Key | jca/Encryption2.java:149:45:149:50 | Key | +| jca/Encryption2.java:150:32:150:98 | EncryptOperation | Nonce | jca/Encryption2.java:149:53:149:59 | Nonce | +| jca/Encryption2.java:150:32:150:98 | EncryptOperation | Output | jca/Encryption2.java:150:32:150:98 | KeyOperationOutput | +| jca/Encryption2.java:150:50:150:97 | Message | Source | jca/Encryption2.java:150:50:150:86 | Constant | +| jca/Encryption2.java:173:36:173:47 | KeyOperationAlgorithm | Mode | jca/Encryption2.java:173:36:173:47 | KeyOperationAlgorithm | +| jca/Encryption2.java:173:36:173:47 | KeyOperationAlgorithm | Padding | jca/Encryption2.java:173:36:173:47 | KeyOperationAlgorithm | +| jca/Encryption2.java:175:19:175:27 | Key | Source | jca/Encryption2.java:132:68:132:88 | Parameter | +| jca/Encryption2.java:176:31:176:52 | MACOperation | Algorithm | jca/Encryption2.java:173:36:173:47 | KeyOperationAlgorithm | +| jca/Encryption2.java:176:31:176:52 | MACOperation | HashAlgorithm | jca/Encryption2.java:176:31:176:52 | MACOperation | +| jca/Encryption2.java:176:31:176:52 | MACOperation | Input | jca/Encryption2.java:176:44:176:51 | Message | +| jca/Encryption2.java:176:31:176:52 | MACOperation | Key | jca/Encryption2.java:175:19:175:27 | Key | +| jca/Encryption2.java:176:31:176:52 | MACOperation | Message | jca/Encryption2.java:176:44:176:51 | Message | +| jca/Encryption2.java:176:31:176:52 | MACOperation | Nonce | jca/Encryption2.java:176:31:176:52 | MACOperation | +| jca/Encryption2.java:176:31:176:52 | MACOperation | Output | jca/Encryption2.java:176:31:176:52 | KeyOperationOutput | +| jca/Encryption2.java:176:44:176:51 | Message | Source | jca/Encryption2.java:74:16:74:44 | SharedSecret | +| jca/Hash.java:76:23:76:66 | Digest | Source | jca/Hash.java:76:23:76:66 | Digest | +| jca/Hash.java:76:23:76:66 | HashOperation | Algorithm | jca/Hash.java:75:58:75:66 | HashAlgorithm | +| jca/Hash.java:76:23:76:66 | HashOperation | Digest | jca/Hash.java:76:23:76:66 | Digest | +| jca/Hash.java:76:23:76:66 | HashOperation | Message | jca/Hash.java:76:37:76:65 | Message | +| jca/Hash.java:76:37:76:65 | Message | Source | jca/Hash.java:76:37:76:54 | Constant | +| jca/Hash.java:89:23:89:70 | Digest | Source | jca/Hash.java:89:23:89:70 | Digest | +| jca/Hash.java:89:23:89:70 | HashOperation | Algorithm | jca/Hash.java:88:61:88:65 | HashAlgorithm | +| jca/Hash.java:89:23:89:70 | HashOperation | Digest | jca/Hash.java:89:23:89:70 | Digest | +| jca/Hash.java:89:23:89:70 | HashOperation | Message | jca/Hash.java:89:40:89:69 | Message | +| jca/Hash.java:89:40:89:69 | Message | Source | jca/Hash.java:89:40:89:58 | Constant | +| jca/Hash.java:134:53:134:67 | KeyOperationAlgorithm | Mode | jca/Hash.java:134:53:134:67 | KeyOperationAlgorithm | +| jca/Hash.java:134:53:134:67 | KeyOperationAlgorithm | Padding | jca/Hash.java:134:53:134:67 | KeyOperationAlgorithm | +| jca/Hash.java:135:28:135:37 | Key | Source | jca/Hash.java:133:43:133:63 | Parameter | +| jca/Hash.java:136:26:136:41 | Message | Source | jca/Hash.java:133:29:133:40 | Parameter | +| jca/Hash.java:137:29:137:44 | SignOperation | Algorithm | jca/Hash.java:134:53:134:67 | KeyOperationAlgorithm | +| jca/Hash.java:137:29:137:44 | SignOperation | HashAlgorithm | jca/Hash.java:134:53:134:67 | HashAlgorithm | +| jca/Hash.java:137:29:137:44 | SignOperation | Input | jca/Hash.java:136:26:136:41 | Message | +| jca/Hash.java:137:29:137:44 | SignOperation | Key | jca/Hash.java:135:28:135:37 | Key | +| jca/Hash.java:137:29:137:44 | SignOperation | Output | jca/Hash.java:137:29:137:44 | SignatureOutput | +| jca/Hash.java:155:53:155:67 | KeyOperationAlgorithm | Mode | jca/Hash.java:155:53:155:67 | KeyOperationAlgorithm | +| jca/Hash.java:155:53:155:67 | KeyOperationAlgorithm | Padding | jca/Hash.java:155:53:155:67 | KeyOperationAlgorithm | +| jca/Hash.java:156:30:156:38 | Key | Source | jca/Hash.java:154:73:154:91 | Parameter | +| jca/Hash.java:157:26:157:41 | Message | Source | jca/Hash.java:154:40:154:51 | Parameter | +| jca/Hash.java:158:16:158:43 | VerifyOperation | Algorithm | jca/Hash.java:155:53:155:67 | KeyOperationAlgorithm | +| jca/Hash.java:158:16:158:43 | VerifyOperation | HashAlgorithm | jca/Hash.java:155:53:155:67 | HashAlgorithm | +| jca/Hash.java:158:16:158:43 | VerifyOperation | Input | jca/Hash.java:157:26:157:41 | Message | +| jca/Hash.java:158:16:158:43 | VerifyOperation | Key | jca/Hash.java:156:30:156:38 | Key | +| jca/Hash.java:158:16:158:43 | VerifyOperation | Signature | jca/Hash.java:158:33:158:42 | SignatureInput | +| jca/Hash.java:158:33:158:42 | SignatureInput | Source | jca/Hash.java:154:54:154:70 | Parameter | +| jca/Hash.java:174:23:174:52 | Digest | Source | jca/Hash.java:174:23:174:52 | Digest | +| jca/Hash.java:174:23:174:52 | HashOperation | Algorithm | jca/Hash.java:173:58:173:66 | HashAlgorithm | +| jca/Hash.java:174:23:174:52 | HashOperation | Digest | jca/Hash.java:174:23:174:52 | Digest | +| jca/Hash.java:174:23:174:52 | HashOperation | Message | jca/Hash.java:174:37:174:51 | Message | +| jca/Hash.java:174:37:174:51 | Message | Source | jca/Hash.java:172:43:172:53 | Parameter | +| jca/Hash.java:195:27:195:57 | Digest | Source | jca/Hash.java:195:27:195:57 | Digest | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:191:32:191:38 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:191:41:191:49 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:191:52:191:60 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:191:63:191:71 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:191:74:191:82 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:191:85:191:94 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:191:97:191:106 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:192:13:192:25 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:192:28:192:40 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Algorithm | jca/Hash.java:192:43:192:47 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | HashOperation | Digest | jca/Hash.java:195:27:195:57 | Digest | +| jca/Hash.java:195:27:195:57 | HashOperation | Message | jca/Hash.java:195:41:195:56 | Message | +| jca/Hash.java:195:41:195:56 | Message | Source | jca/Hash.java:190:43:190:54 | Parameter | +| jca/Hash.java:212:32:212:41 | KeyOperationAlgorithm | Mode | jca/Hash.java:212:32:212:41 | KeyOperationAlgorithm | +| jca/Hash.java:212:32:212:41 | KeyOperationAlgorithm | Padding | jca/Hash.java:212:32:212:41 | KeyOperationAlgorithm | +| jca/Hash.java:212:44:212:55 | KeyOperationAlgorithm | Mode | jca/Hash.java:212:44:212:55 | KeyOperationAlgorithm | +| jca/Hash.java:212:44:212:55 | KeyOperationAlgorithm | Padding | jca/Hash.java:212:44:212:55 | KeyOperationAlgorithm | +| jca/Hash.java:212:58:212:69 | KeyOperationAlgorithm | Mode | jca/Hash.java:212:58:212:69 | KeyOperationAlgorithm | +| jca/Hash.java:212:58:212:69 | KeyOperationAlgorithm | Padding | jca/Hash.java:212:58:212:69 | KeyOperationAlgorithm | +| jca/Hash.java:212:72:212:83 | KeyOperationAlgorithm | Mode | jca/Hash.java:212:72:212:83 | KeyOperationAlgorithm | +| jca/Hash.java:212:72:212:83 | KeyOperationAlgorithm | Padding | jca/Hash.java:212:72:212:83 | KeyOperationAlgorithm | +| jca/Hash.java:212:86:212:99 | KeyOperationAlgorithm | Mode | jca/Hash.java:212:86:212:99 | KeyOperationAlgorithm | +| jca/Hash.java:212:86:212:99 | KeyOperationAlgorithm | Padding | jca/Hash.java:212:86:212:99 | KeyOperationAlgorithm | +| jca/Hash.java:212:102:212:115 | KeyOperationAlgorithm | Mode | jca/Hash.java:212:102:212:115 | KeyOperationAlgorithm | +| jca/Hash.java:212:102:212:115 | KeyOperationAlgorithm | Padding | jca/Hash.java:212:102:212:115 | KeyOperationAlgorithm | +| jca/Hash.java:216:22:216:30 | Key | Source | jca/Hash.java:211:57:211:66 | Parameter | +| jca/Hash.java:217:27:217:55 | MACOperation | Algorithm | jca/Hash.java:212:32:212:41 | KeyOperationAlgorithm | +| jca/Hash.java:217:27:217:55 | MACOperation | Algorithm | jca/Hash.java:212:44:212:55 | KeyOperationAlgorithm | +| jca/Hash.java:217:27:217:55 | MACOperation | Algorithm | jca/Hash.java:212:58:212:69 | KeyOperationAlgorithm | +| jca/Hash.java:217:27:217:55 | MACOperation | Algorithm | jca/Hash.java:212:72:212:83 | KeyOperationAlgorithm | +| jca/Hash.java:217:27:217:55 | MACOperation | Algorithm | jca/Hash.java:212:86:212:99 | KeyOperationAlgorithm | +| jca/Hash.java:217:27:217:55 | MACOperation | Algorithm | jca/Hash.java:212:102:212:115 | KeyOperationAlgorithm | +| jca/Hash.java:217:27:217:55 | MACOperation | HashAlgorithm | jca/Hash.java:217:27:217:55 | MACOperation | +| jca/Hash.java:217:27:217:55 | MACOperation | Input | jca/Hash.java:217:39:217:54 | Message | +| jca/Hash.java:217:27:217:55 | MACOperation | Key | jca/Hash.java:216:22:216:30 | Key | +| jca/Hash.java:217:27:217:55 | MACOperation | Message | jca/Hash.java:217:39:217:54 | Message | +| jca/Hash.java:217:27:217:55 | MACOperation | Nonce | jca/Hash.java:217:27:217:55 | MACOperation | +| jca/Hash.java:217:27:217:55 | MACOperation | Output | jca/Hash.java:217:27:217:55 | KeyOperationOutput | +| jca/Hash.java:217:39:217:54 | Message | Source | jca/Hash.java:211:43:211:54 | Parameter | +| jca/Hash.java:235:42:235:63 | Message | Source | jca/Hash.java:232:40:232:54 | Parameter | +| jca/Hash.java:235:66:235:69 | Salt | Source | jca/Hash.java:310:9:310:42 | RandomNumberGeneration | +| jca/Hash.java:235:66:235:69 | Salt | Source | jca/Hash.java:310:38:310:41 | RandomNumberGeneration | +| jca/Hash.java:236:65:236:86 | HMACAlgorithm | H | jca/Hash.java:236:65:236:86 | HashAlgorithm | +| jca/Hash.java:236:65:236:86 | KeyDerivationAlgorithm | PRF | jca/Hash.java:236:65:236:86 | HMACAlgorithm | +| jca/Hash.java:237:23:237:50 | KeyDerivation | Algorithm | jca/Hash.java:236:65:236:86 | KeyDerivationAlgorithm | +| jca/Hash.java:237:23:237:50 | KeyDerivation | Input | jca/Hash.java:235:42:235:63 | Message | +| jca/Hash.java:237:23:237:50 | KeyDerivation | Output | jca/Hash.java:237:23:237:50 | Key | +| jca/Hash.java:237:23:237:50 | KeyDerivation | Salt | jca/Hash.java:235:66:235:69 | Salt | +| jca/Hash.java:252:23:252:70 | Digest | Source | jca/Hash.java:252:23:252:70 | Digest | +| jca/Hash.java:252:23:252:70 | HashOperation | Algorithm | jca/Hash.java:294:16:294:66 | LocalData | +| jca/Hash.java:252:23:252:70 | HashOperation | Algorithm | jca/Hash.java:294:57:294:65 | HashAlgorithm | +| jca/Hash.java:252:23:252:70 | HashOperation | Digest | jca/Hash.java:252:23:252:70 | Digest | +| jca/Hash.java:252:23:252:70 | HashOperation | Message | jca/Hash.java:252:37:252:69 | Message | +| jca/Hash.java:252:37:252:69 | Message | Source | jca/Hash.java:252:37:252:58 | Constant | +| jca/Hash.java:270:27:270:30 | Message | Source | jca/Hash.java:269:27:269:38 | Constant | +| jca/Hash.java:271:40:271:54 | Digest | Source | jca/Hash.java:271:40:271:54 | Digest | +| jca/Hash.java:271:40:271:54 | HashOperation | Algorithm | jca/Hash.java:266:32:266:40 | HashAlgorithm | +| jca/Hash.java:271:40:271:54 | HashOperation | Algorithm | jca/Hash.java:266:43:266:51 | HashAlgorithm | +| jca/Hash.java:271:40:271:54 | HashOperation | Algorithm | jca/Hash.java:266:54:266:63 | HashAlgorithm | +| jca/Hash.java:271:40:271:54 | HashOperation | Algorithm | jca/Hash.java:266:66:266:75 | HashAlgorithm | +| jca/Hash.java:271:40:271:54 | HashOperation | Digest | jca/Hash.java:271:40:271:54 | Digest | +| jca/Hash.java:271:40:271:54 | HashOperation | Message | jca/Hash.java:270:27:270:30 | Message | +| jca/IVArtifact.java:30:44:30:65 | KeyOperationAlgorithm | Mode | jca/IVArtifact.java:30:44:30:65 | ModeOfOperation | +| jca/IVArtifact.java:30:44:30:65 | KeyOperationAlgorithm | Padding | jca/IVArtifact.java:30:44:30:65 | PaddingAlgorithm | +| jca/IVArtifact.java:31:42:31:44 | Key | Source | jca/IVArtifact.java:76:16:76:35 | Key | +| jca/IVArtifact.java:31:47:31:52 | Nonce | Source | jca/IVArtifact.java:81:9:81:40 | RandomNumberGeneration | +| jca/IVArtifact.java:31:47:31:52 | Nonce | Source | jca/IVArtifact.java:81:38:81:39 | RandomNumberGeneration | +| jca/IVArtifact.java:32:29:32:73 | EncryptOperation | Algorithm | jca/IVArtifact.java:30:44:30:65 | KeyOperationAlgorithm | +| jca/IVArtifact.java:32:29:32:73 | EncryptOperation | Input | jca/IVArtifact.java:32:44:32:72 | Message | +| jca/IVArtifact.java:32:29:32:73 | EncryptOperation | Key | jca/IVArtifact.java:31:42:31:44 | Key | +| jca/IVArtifact.java:32:29:32:73 | EncryptOperation | Nonce | jca/IVArtifact.java:31:47:31:52 | Nonce | +| jca/IVArtifact.java:32:29:32:73 | EncryptOperation | Output | jca/IVArtifact.java:32:29:32:73 | KeyOperationOutput | +| jca/IVArtifact.java:32:44:32:72 | Message | Source | jca/IVArtifact.java:32:44:32:61 | Constant | +| jca/IVArtifact.java:38:42:38:44 | Key | Source | jca/IVArtifact.java:76:16:76:35 | Key | +| jca/IVArtifact.java:38:47:38:52 | Nonce | Source | jca/IVArtifact.java:81:9:81:40 | RandomNumberGeneration | +| jca/IVArtifact.java:38:47:38:52 | Nonce | Source | jca/IVArtifact.java:81:38:81:39 | RandomNumberGeneration | +| jca/IVArtifact.java:38:47:38:52 | Nonce | Source | jca/IVArtifact.java:87:32:87:33 | RandomNumberGeneration | +| jca/IVArtifact.java:39:29:39:53 | EncryptOperation | Algorithm | jca/IVArtifact.java:70:16:70:81 | LocalData | +| jca/IVArtifact.java:39:29:39:53 | EncryptOperation | Algorithm | jca/IVArtifact.java:70:59:70:80 | KeyOperationAlgorithm | +| jca/IVArtifact.java:39:29:39:53 | EncryptOperation | Input | jca/IVArtifact.java:39:44:39:52 | Message | +| jca/IVArtifact.java:39:29:39:53 | EncryptOperation | Key | jca/IVArtifact.java:38:42:38:44 | Key | +| jca/IVArtifact.java:39:29:39:53 | EncryptOperation | Nonce | jca/IVArtifact.java:38:47:38:52 | Nonce | +| jca/IVArtifact.java:39:29:39:53 | EncryptOperation | Output | jca/IVArtifact.java:39:29:39:53 | KeyOperationOutput | +| jca/IVArtifact.java:39:44:39:52 | Message | Source | jca/IVArtifact.java:49:27:49:42 | Constant | +| jca/IVArtifact.java:70:59:70:80 | KeyOperationAlgorithm | Mode | jca/IVArtifact.java:70:59:70:80 | ModeOfOperation | +| jca/IVArtifact.java:70:59:70:80 | KeyOperationAlgorithm | Padding | jca/IVArtifact.java:70:59:70:80 | PaddingAlgorithm | +| jca/IVArtifact.java:76:16:76:35 | KeyGeneration | Algorithm | jca/IVArtifact.java:74:56:74:60 | KeyOperationAlgorithm | +| jca/IVArtifact.java:76:16:76:35 | KeyGeneration | Output | jca/IVArtifact.java:76:16:76:35 | Key | +| jca/IVArtifact.java:105:44:105:62 | KeyOperationAlgorithm | Mode | jca/IVArtifact.java:105:44:105:62 | ModeOfOperation | +| jca/IVArtifact.java:105:44:105:62 | KeyOperationAlgorithm | Padding | jca/IVArtifact.java:105:44:105:62 | PaddingAlgorithm | +| jca/IVArtifact.java:108:42:108:44 | Key | Source | jca/IVArtifact.java:255:29:255:44 | Key | +| jca/IVArtifact.java:108:47:108:50 | Nonce | Source | jca/IVArtifact.java:108:47:108:50 | Nonce | +| jca/IVArtifact.java:109:16:109:40 | EncryptOperation | Algorithm | jca/IVArtifact.java:105:44:105:62 | KeyOperationAlgorithm | +| jca/IVArtifact.java:109:16:109:40 | EncryptOperation | Input | jca/IVArtifact.java:109:31:109:39 | Message | +| jca/IVArtifact.java:109:16:109:40 | EncryptOperation | Key | jca/IVArtifact.java:108:42:108:44 | Key | +| jca/IVArtifact.java:109:16:109:40 | EncryptOperation | Nonce | jca/IVArtifact.java:108:47:108:50 | Nonce | +| jca/IVArtifact.java:109:16:109:40 | EncryptOperation | Output | jca/IVArtifact.java:109:16:109:40 | KeyOperationOutput | +| jca/IVArtifact.java:109:31:109:39 | Message | Source | jca/IVArtifact.java:256:32:256:47 | Constant | +| jca/IVArtifact.java:132:44:132:62 | KeyOperationAlgorithm | Mode | jca/IVArtifact.java:132:44:132:62 | ModeOfOperation | +| jca/IVArtifact.java:132:44:132:62 | KeyOperationAlgorithm | Padding | jca/IVArtifact.java:132:44:132:62 | PaddingAlgorithm | +| jca/IVArtifact.java:134:42:134:44 | Key | Source | jca/IVArtifact.java:255:29:255:44 | Key | +| jca/IVArtifact.java:134:47:134:50 | Nonce | Source | jca/IVArtifact.java:116:31:116:34 | Constant | +| jca/IVArtifact.java:134:47:134:50 | Nonce | Source | jca/IVArtifact.java:130:13:130:50 | RandomNumberGeneration | +| jca/IVArtifact.java:134:47:134:50 | Nonce | Source | jca/IVArtifact.java:130:42:130:49 | RandomNumberGeneration | +| jca/IVArtifact.java:135:16:135:40 | EncryptOperation | Algorithm | jca/IVArtifact.java:132:44:132:62 | KeyOperationAlgorithm | +| jca/IVArtifact.java:135:16:135:40 | EncryptOperation | Input | jca/IVArtifact.java:135:31:135:39 | Message | +| jca/IVArtifact.java:135:16:135:40 | EncryptOperation | Key | jca/IVArtifact.java:134:42:134:44 | Key | +| jca/IVArtifact.java:135:16:135:40 | EncryptOperation | Nonce | jca/IVArtifact.java:134:47:134:50 | Nonce | +| jca/IVArtifact.java:135:16:135:40 | EncryptOperation | Output | jca/IVArtifact.java:135:16:135:40 | KeyOperationOutput | +| jca/IVArtifact.java:135:31:135:39 | Message | Source | jca/IVArtifact.java:256:32:256:47 | Constant | +| jca/IVArtifact.java:154:31:154:78 | Digest | Source | jca/IVArtifact.java:154:31:154:78 | Digest | +| jca/IVArtifact.java:154:31:154:78 | HashOperation | Algorithm | jca/IVArtifact.java:153:58:153:66 | HashAlgorithm | +| jca/IVArtifact.java:154:31:154:78 | HashOperation | Digest | jca/IVArtifact.java:154:31:154:78 | Digest | +| jca/IVArtifact.java:154:31:154:78 | HashOperation | Message | jca/IVArtifact.java:154:45:154:77 | Message | +| jca/IVArtifact.java:154:45:154:77 | Message | Source | jca/IVArtifact.java:154:45:154:59 | Constant | +| jca/IVArtifact.java:156:44:156:62 | KeyOperationAlgorithm | Mode | jca/IVArtifact.java:156:44:156:62 | ModeOfOperation | +| jca/IVArtifact.java:156:44:156:62 | KeyOperationAlgorithm | Padding | jca/IVArtifact.java:156:44:156:62 | PaddingAlgorithm | +| jca/IVArtifact.java:158:42:158:44 | Key | Source | jca/IVArtifact.java:255:29:255:44 | Key | +| jca/IVArtifact.java:158:47:158:50 | Nonce | Source | jca/IVArtifact.java:158:47:158:50 | Nonce | +| jca/IVArtifact.java:159:16:159:40 | EncryptOperation | Algorithm | jca/IVArtifact.java:156:44:156:62 | KeyOperationAlgorithm | +| jca/IVArtifact.java:159:16:159:40 | EncryptOperation | Input | jca/IVArtifact.java:159:31:159:39 | Message | +| jca/IVArtifact.java:159:16:159:40 | EncryptOperation | Key | jca/IVArtifact.java:158:42:158:44 | Key | +| jca/IVArtifact.java:159:16:159:40 | EncryptOperation | Nonce | jca/IVArtifact.java:158:47:158:50 | Nonce | +| jca/IVArtifact.java:159:16:159:40 | EncryptOperation | Output | jca/IVArtifact.java:159:16:159:40 | KeyOperationOutput | +| jca/IVArtifact.java:159:31:159:39 | Message | Source | jca/IVArtifact.java:256:32:256:47 | Constant | +| jca/IVArtifact.java:180:48:180:66 | KeyOperationAlgorithm | Mode | jca/IVArtifact.java:180:48:180:66 | ModeOfOperation | +| jca/IVArtifact.java:180:48:180:66 | KeyOperationAlgorithm | Padding | jca/IVArtifact.java:180:48:180:66 | PaddingAlgorithm | +| jca/IVArtifact.java:182:46:182:48 | Key | Source | jca/IVArtifact.java:255:29:255:44 | Key | +| jca/IVArtifact.java:182:51:182:54 | Nonce | Source | jca/IVArtifact.java:177:9:177:40 | RandomNumberGeneration | +| jca/IVArtifact.java:182:51:182:54 | Nonce | Source | jca/IVArtifact.java:177:38:177:39 | RandomNumberGeneration | +| jca/IVArtifact.java:183:30:183:58 | EncryptOperation | Algorithm | jca/IVArtifact.java:180:48:180:66 | KeyOperationAlgorithm | +| jca/IVArtifact.java:183:30:183:58 | EncryptOperation | Input | jca/IVArtifact.java:183:45:183:57 | Message | +| jca/IVArtifact.java:183:30:183:58 | EncryptOperation | Key | jca/IVArtifact.java:182:46:182:48 | Key | +| jca/IVArtifact.java:183:30:183:58 | EncryptOperation | Nonce | jca/IVArtifact.java:182:51:182:54 | Nonce | +| jca/IVArtifact.java:183:30:183:58 | EncryptOperation | Output | jca/IVArtifact.java:183:30:183:58 | KeyOperationOutput | +| jca/IVArtifact.java:183:45:183:57 | Message | Source | jca/IVArtifact.java:275:34:275:46 | Constant | +| jca/IVArtifact.java:183:45:183:57 | Message | Source | jca/IVArtifact.java:275:60:275:72 | Constant | +| jca/IVArtifact.java:183:45:183:57 | Message | Source | jca/IVArtifact.java:275:86:275:100 | Constant | +| jca/IVArtifact.java:198:44:198:62 | KeyOperationAlgorithm | Mode | jca/IVArtifact.java:198:44:198:62 | ModeOfOperation | +| jca/IVArtifact.java:198:44:198:62 | KeyOperationAlgorithm | Padding | jca/IVArtifact.java:198:44:198:62 | PaddingAlgorithm | +| jca/IVArtifact.java:201:42:201:44 | Key | Source | jca/IVArtifact.java:215:53:215:65 | Parameter | +| jca/IVArtifact.java:201:42:201:44 | Key | Source | jca/IVArtifact.java:235:60:235:72 | Parameter | +| jca/IVArtifact.java:201:47:201:50 | Nonce | Source | jca/IVArtifact.java:201:47:201:50 | Nonce | +| jca/IVArtifact.java:202:16:202:40 | EncryptOperation | Algorithm | jca/IVArtifact.java:198:44:198:62 | KeyOperationAlgorithm | +| jca/IVArtifact.java:202:16:202:40 | EncryptOperation | Input | jca/IVArtifact.java:202:31:202:39 | Message | +| jca/IVArtifact.java:202:16:202:40 | EncryptOperation | Key | jca/IVArtifact.java:201:42:201:44 | Key | +| jca/IVArtifact.java:202:16:202:40 | EncryptOperation | Nonce | jca/IVArtifact.java:201:47:201:50 | Nonce | +| jca/IVArtifact.java:202:16:202:40 | EncryptOperation | Output | jca/IVArtifact.java:202:16:202:40 | KeyOperationOutput | +| jca/IVArtifact.java:202:31:202:39 | Message | Source | jca/IVArtifact.java:215:68:215:83 | Parameter | +| jca/IVArtifact.java:202:31:202:39 | Message | Source | jca/IVArtifact.java:235:75:235:90 | Parameter | +| jca/IVArtifact.java:255:29:255:44 | KeyGeneration | Algorithm | jca/IVArtifact.java:253:56:253:60 | KeyOperationAlgorithm | +| jca/IVArtifact.java:255:29:255:44 | KeyGeneration | Output | jca/IVArtifact.java:255:29:255:44 | Key | +| jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | Key | Algorithm | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | EllipticCurve | +| jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | KeyGeneration | Algorithm | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | EllipticCurve | +| jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | KeyGeneration | Output | jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | Key | +| jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | Key | Algorithm | jca/KeyAgreementHybridCryptosystem.java:58:61:58:68 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | KeyGeneration | Algorithm | jca/KeyAgreementHybridCryptosystem.java:58:61:58:68 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | KeyGeneration | Output | jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | Key | +| jca/KeyAgreementHybridCryptosystem.java:68:17:68:26 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | Key | +| jca/KeyAgreementHybridCryptosystem.java:68:17:68:26 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | Key | +| jca/KeyAgreementHybridCryptosystem.java:69:20:69:28 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | Key | +| jca/KeyAgreementHybridCryptosystem.java:69:20:69:28 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | Key | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | KeyAgreementOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:104:90:104:95 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | KeyAgreementOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:125:95:125:100 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | KeyAgreementOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:149:91:149:98 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | KeyAgreementOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:169:95:169:102 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | KeyAgreementOperation | Output | jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | SharedSecret | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | KeyAgreementOperation | PeerKey | jca/KeyAgreementHybridCryptosystem.java:69:20:69:28 | Key | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | KeyAgreementOperation | ServerKey | jca/KeyAgreementHybridCryptosystem.java:68:17:68:26 | Key | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | SharedSecret | Source | jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | SharedSecret | +| jca/KeyAgreementHybridCryptosystem.java:79:23:79:42 | Digest | Source | jca/KeyAgreementHybridCryptosystem.java:79:23:79:42 | Digest | +| jca/KeyAgreementHybridCryptosystem.java:79:23:79:42 | HashOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | HashAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:79:23:79:42 | HashOperation | Digest | jca/KeyAgreementHybridCryptosystem.java:79:23:79:42 | Digest | +| jca/KeyAgreementHybridCryptosystem.java:79:23:79:42 | HashOperation | Message | jca/KeyAgreementHybridCryptosystem.java:79:37:79:41 | Message | +| jca/KeyAgreementHybridCryptosystem.java:79:37:79:41 | Message | Source | jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | SharedSecret | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | KeyOperationAlgorithm | Mode | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | ModeOfOperation | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | KeyOperationAlgorithm | Padding | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | PaddingAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:112:42:112:47 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:112:42:112:47 | Key | +| jca/KeyAgreementHybridCryptosystem.java:112:50:112:53 | Nonce | Source | jca/KeyAgreementHybridCryptosystem.java:110:9:110:40 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:112:50:112:53 | Nonce | Source | jca/KeyAgreementHybridCryptosystem.java:110:38:110:39 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | EncryptOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | EncryptOperation | Input | jca/KeyAgreementHybridCryptosystem.java:113:44:113:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | EncryptOperation | Key | jca/KeyAgreementHybridCryptosystem.java:112:42:112:47 | Key | +| jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | EncryptOperation | Nonce | jca/KeyAgreementHybridCryptosystem.java:112:50:112:53 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | EncryptOperation | Output | jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:113:44:113:52 | Message | Source | jca/KeyAgreementHybridCryptosystem.java:188:58:188:73 | Parameter | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | KeyOperationAlgorithm | Mode | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | ModeOfOperation | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | KeyOperationAlgorithm | Padding | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | PaddingAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:132:42:132:47 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:132:42:132:47 | Key | +| jca/KeyAgreementHybridCryptosystem.java:132:50:132:53 | Nonce | Source | jca/KeyAgreementHybridCryptosystem.java:132:50:132:53 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | EncryptOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | EncryptOperation | Input | jca/KeyAgreementHybridCryptosystem.java:133:44:133:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | EncryptOperation | Key | jca/KeyAgreementHybridCryptosystem.java:132:42:132:47 | Key | +| jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | EncryptOperation | Nonce | jca/KeyAgreementHybridCryptosystem.java:132:50:132:53 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | EncryptOperation | Output | jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:133:44:133:52 | Message | Source | jca/KeyAgreementHybridCryptosystem.java:188:58:188:73 | Parameter | +| jca/KeyAgreementHybridCryptosystem.java:150:33:150:89 | Digest | Source | jca/KeyAgreementHybridCryptosystem.java:150:33:150:89 | Digest | +| jca/KeyAgreementHybridCryptosystem.java:150:33:150:89 | HashOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | HashAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:150:33:150:89 | HashOperation | Digest | jca/KeyAgreementHybridCryptosystem.java:150:33:150:89 | Digest | +| jca/KeyAgreementHybridCryptosystem.java:150:33:150:89 | HashOperation | Message | jca/KeyAgreementHybridCryptosystem.java:150:77:150:88 | Message | +| jca/KeyAgreementHybridCryptosystem.java:150:77:150:88 | Message | Source | jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | SharedSecret | +| jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | KeyOperationAlgorithm | Mode | jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | KeyOperationAlgorithm | Padding | jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:156:42:156:50 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:156:42:156:50 | Key | +| jca/KeyAgreementHybridCryptosystem.java:156:53:156:78 | Nonce | Source | jca/KeyAgreementHybridCryptosystem.java:155:9:155:43 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:156:53:156:78 | Nonce | Source | jca/KeyAgreementHybridCryptosystem.java:155:38:155:42 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | EncryptOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | EncryptOperation | Input | jca/KeyAgreementHybridCryptosystem.java:157:44:157:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | EncryptOperation | Key | jca/KeyAgreementHybridCryptosystem.java:156:42:156:50 | Key | +| jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | EncryptOperation | Nonce | jca/KeyAgreementHybridCryptosystem.java:156:53:156:78 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | EncryptOperation | Output | jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:157:44:157:52 | Message | Source | jca/KeyAgreementHybridCryptosystem.java:188:58:188:73 | Parameter | +| jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | KeyOperationAlgorithm | Mode | jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | KeyOperationAlgorithm | Padding | jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:175:42:175:50 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:175:42:175:50 | Key | +| jca/KeyAgreementHybridCryptosystem.java:175:53:175:83 | Nonce | Source | jca/KeyAgreementHybridCryptosystem.java:175:53:175:83 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | EncryptOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | EncryptOperation | Input | jca/KeyAgreementHybridCryptosystem.java:176:44:176:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | EncryptOperation | Key | jca/KeyAgreementHybridCryptosystem.java:175:42:175:50 | Key | +| jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | EncryptOperation | Nonce | jca/KeyAgreementHybridCryptosystem.java:175:53:175:83 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | EncryptOperation | Output | jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:176:44:176:52 | Message | Source | jca/KeyAgreementHybridCryptosystem.java:188:58:188:73 | Parameter | +| jca/KeyAgreementHybridCryptosystem.java:215:42:215:66 | Message | Source | jca/KeyAgreementHybridCryptosystem.java:212:58:212:70 | Parameter | +| jca/KeyAgreementHybridCryptosystem.java:215:69:215:72 | Salt | Source | jca/KeyAgreementHybridCryptosystem.java:269:9:269:42 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:215:69:215:72 | Salt | Source | jca/KeyAgreementHybridCryptosystem.java:269:38:269:41 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HMACAlgorithm | H | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HashAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | KeyDerivationAlgorithm | PRF | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HMACAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | KeyDerivation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | KeyDerivationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | KeyDerivation | Input | jca/KeyAgreementHybridCryptosystem.java:215:42:215:66 | Message | +| jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | KeyDerivation | Output | jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | Key | +| jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | KeyDerivation | Salt | jca/KeyAgreementHybridCryptosystem.java:215:69:215:72 | Salt | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | KeyOperationAlgorithm | Mode | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | ModeOfOperation | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | KeyOperationAlgorithm | Padding | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | PaddingAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:227:42:227:54 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:227:42:227:54 | Key | +| jca/KeyAgreementHybridCryptosystem.java:227:57:227:63 | Nonce | Source | jca/KeyAgreementHybridCryptosystem.java:225:9:225:40 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:227:57:227:63 | Nonce | Source | jca/KeyAgreementHybridCryptosystem.java:225:38:225:39 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | EncryptOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | EncryptOperation | Input | jca/KeyAgreementHybridCryptosystem.java:228:44:228:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | EncryptOperation | Key | jca/KeyAgreementHybridCryptosystem.java:227:42:227:54 | Key | +| jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | EncryptOperation | Nonce | jca/KeyAgreementHybridCryptosystem.java:227:57:227:63 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | EncryptOperation | Output | jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:228:44:228:52 | Message | Source | jca/KeyAgreementHybridCryptosystem.java:212:73:212:88 | Parameter | +| jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | KeyOperationAlgorithm | Mode | jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | KeyOperationAlgorithm | Padding | jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:231:18:231:30 | Key | Source | jca/KeyAgreementHybridCryptosystem.java:231:18:231:30 | Key | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | Algorithm | jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | HashAlgorithm | jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | Input | jca/KeyAgreementHybridCryptosystem.java:232:42:232:51 | Message | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | Key | jca/KeyAgreementHybridCryptosystem.java:231:18:231:30 | Key | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | Message | jca/KeyAgreementHybridCryptosystem.java:232:42:232:51 | Message | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | Nonce | jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | Output | jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:232:42:232:51 | Message | Source | jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:261:16:261:31 | KeyGeneration | Algorithm | jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:261:16:261:31 | KeyGeneration | Output | jca/KeyAgreementHybridCryptosystem.java:261:16:261:31 | Key | +| jca/KeyArtifact.java:20:31:20:50 | KeyGeneration | Algorithm | jca/KeyArtifact.java:18:56:18:60 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:20:31:20:50 | KeyGeneration | Output | jca/KeyArtifact.java:20:31:20:50 | Key | +| jca/KeyArtifact.java:25:30:25:49 | KeyGeneration | Algorithm | jca/KeyArtifact.java:23:43:23:47 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:25:30:25:49 | KeyGeneration | Output | jca/KeyArtifact.java:25:30:25:49 | Key | +| jca/KeyArtifact.java:32:30:32:57 | Key | Algorithm | jca/KeyArtifact.java:30:68:30:72 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:32:30:32:57 | KeyGeneration | Algorithm | jca/KeyArtifact.java:30:68:30:72 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:32:30:32:57 | KeyGeneration | Output | jca/KeyArtifact.java:32:30:32:57 | Key | +| jca/KeyArtifact.java:37:29:37:56 | Key | Algorithm | jca/KeyArtifact.java:35:51:35:55 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:37:29:37:56 | KeyGeneration | Algorithm | jca/KeyArtifact.java:35:51:35:55 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:37:29:37:56 | KeyGeneration | Output | jca/KeyArtifact.java:37:29:37:56 | Key | +| jca/KeyArtifact.java:42:26:42:53 | Key | Algorithm | jca/KeyArtifact.java:42:26:42:53 | Key | +| jca/KeyArtifact.java:42:26:42:53 | KeyGeneration | Algorithm | jca/KeyArtifact.java:42:26:42:53 | KeyGeneration | +| jca/KeyArtifact.java:42:26:42:53 | KeyGeneration | Output | jca/KeyArtifact.java:42:26:42:53 | Key | +| jca/KeyArtifact.java:66:32:66:51 | KeyGeneration | Algorithm | jca/KeyArtifact.java:62:28:62:73 | LocalData | +| jca/KeyArtifact.java:66:32:66:51 | KeyGeneration | Algorithm | jca/KeyArtifact.java:62:68:62:72 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:66:32:66:51 | KeyGeneration | Output | jca/KeyArtifact.java:66:32:66:51 | Key | +| jca/KeyArtifact.java:73:16:73:43 | Key | Algorithm | jca/KeyArtifact.java:78:32:78:36 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:73:16:73:43 | Key | Algorithm | jca/KeyArtifact.java:78:45:78:53 | Constant | +| jca/KeyArtifact.java:73:16:73:43 | KeyGeneration | Algorithm | jca/KeyArtifact.java:78:32:78:36 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:73:16:73:43 | KeyGeneration | Algorithm | jca/KeyArtifact.java:78:45:78:53 | Constant | +| jca/KeyArtifact.java:73:16:73:43 | KeyGeneration | Output | jca/KeyArtifact.java:73:16:73:43 | Key | +| jca/KeyDerivation1.java:80:42:80:63 | Message | Source | jca/KeyDerivation1.java:78:39:78:53 | Parameter | +| jca/KeyDerivation1.java:80:66:80:69 | Salt | Source | jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:80:66:80:69 | Salt | Source | jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyDerivation1.java:81:65:81:86 | HMACAlgorithm | H | jca/KeyDerivation1.java:81:65:81:86 | HashAlgorithm | +| jca/KeyDerivation1.java:81:65:81:86 | KeyDerivationAlgorithm | PRF | jca/KeyDerivation1.java:81:65:81:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:82:22:82:49 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:81:65:81:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:82:22:82:49 | KeyDerivation | Input | jca/KeyDerivation1.java:80:42:80:63 | Message | +| jca/KeyDerivation1.java:82:22:82:49 | KeyDerivation | Output | jca/KeyDerivation1.java:82:22:82:49 | Key | +| jca/KeyDerivation1.java:82:22:82:49 | KeyDerivation | Salt | jca/KeyDerivation1.java:80:66:80:69 | Salt | +| jca/KeyDerivation1.java:94:42:94:63 | Message | Source | jca/KeyDerivation1.java:92:36:92:50 | Parameter | +| jca/KeyDerivation1.java:94:66:94:69 | Salt | Source | jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:94:66:94:69 | Salt | Source | jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyDerivation1.java:95:65:95:86 | HMACAlgorithm | H | jca/KeyDerivation1.java:95:65:95:86 | HashAlgorithm | +| jca/KeyDerivation1.java:95:65:95:86 | KeyDerivationAlgorithm | PRF | jca/KeyDerivation1.java:95:65:95:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:96:22:96:49 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:95:65:95:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:96:22:96:49 | KeyDerivation | Input | jca/KeyDerivation1.java:94:42:94:63 | Message | +| jca/KeyDerivation1.java:96:22:96:49 | KeyDerivation | Output | jca/KeyDerivation1.java:96:22:96:49 | Key | +| jca/KeyDerivation1.java:96:22:96:49 | KeyDerivation | Salt | jca/KeyDerivation1.java:94:66:94:69 | Salt | +| jca/KeyDerivation1.java:108:42:108:63 | Message | Source | jca/KeyDerivation1.java:106:37:106:51 | Parameter | +| jca/KeyDerivation1.java:108:66:108:69 | Salt | Source | jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:108:66:108:69 | Salt | Source | jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyDerivation1.java:109:65:109:86 | HMACAlgorithm | H | jca/KeyDerivation1.java:109:65:109:86 | HashAlgorithm | +| jca/KeyDerivation1.java:109:65:109:86 | KeyDerivationAlgorithm | PRF | jca/KeyDerivation1.java:109:65:109:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:110:22:110:49 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:109:65:109:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:110:22:110:49 | KeyDerivation | Input | jca/KeyDerivation1.java:108:42:108:63 | Message | +| jca/KeyDerivation1.java:110:22:110:49 | KeyDerivation | Output | jca/KeyDerivation1.java:110:22:110:49 | Key | +| jca/KeyDerivation1.java:110:22:110:49 | KeyDerivation | Salt | jca/KeyDerivation1.java:108:66:108:69 | Salt | +| jca/KeyDerivation1.java:122:42:122:63 | Message | Source | jca/KeyDerivation1.java:120:32:120:46 | Parameter | +| jca/KeyDerivation1.java:122:66:122:69 | Salt | Source | jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:122:66:122:69 | Salt | Source | jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyDerivation1.java:123:65:123:84 | HMACAlgorithm | H | jca/KeyDerivation1.java:123:65:123:84 | HashAlgorithm | +| jca/KeyDerivation1.java:123:65:123:84 | KeyDerivationAlgorithm | PRF | jca/KeyDerivation1.java:123:65:123:84 | HMACAlgorithm | +| jca/KeyDerivation1.java:124:22:124:49 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:123:65:123:84 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:124:22:124:49 | KeyDerivation | Input | jca/KeyDerivation1.java:122:42:122:63 | Message | +| jca/KeyDerivation1.java:124:22:124:49 | KeyDerivation | Output | jca/KeyDerivation1.java:124:22:124:49 | Key | +| jca/KeyDerivation1.java:124:22:124:49 | KeyDerivation | Salt | jca/KeyDerivation1.java:122:66:122:69 | Salt | +| jca/KeyDerivation1.java:136:42:136:63 | Message | Source | jca/KeyDerivation1.java:134:34:134:48 | Parameter | +| jca/KeyDerivation1.java:136:66:136:69 | Salt | Source | jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:136:66:136:69 | Salt | Source | jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyDerivation1.java:137:65:137:86 | HMACAlgorithm | H | jca/KeyDerivation1.java:137:65:137:86 | HashAlgorithm | +| jca/KeyDerivation1.java:137:65:137:86 | KeyDerivationAlgorithm | PRF | jca/KeyDerivation1.java:137:65:137:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:138:22:138:49 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:137:65:137:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:138:22:138:49 | KeyDerivation | Input | jca/KeyDerivation1.java:136:42:136:63 | Message | +| jca/KeyDerivation1.java:138:22:138:49 | KeyDerivation | Output | jca/KeyDerivation1.java:138:22:138:49 | Key | +| jca/KeyDerivation1.java:138:22:138:49 | KeyDerivation | Salt | jca/KeyDerivation1.java:136:66:136:69 | Salt | +| jca/KeyDerivation1.java:157:42:157:63 | Message | Source | jca/KeyDerivation1.java:154:28:154:42 | Parameter | +| jca/KeyDerivation1.java:157:66:157:69 | Salt | Source | jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:157:66:157:69 | Salt | Source | jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyDerivation1.java:159:22:159:49 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:158:65:158:72 | Constant | +| jca/KeyDerivation1.java:159:22:159:49 | KeyDerivation | Input | jca/KeyDerivation1.java:157:42:157:63 | Message | +| jca/KeyDerivation1.java:159:22:159:49 | KeyDerivation | Output | jca/KeyDerivation1.java:159:22:159:49 | Key | +| jca/KeyDerivation1.java:159:22:159:49 | KeyDerivation | Salt | jca/KeyDerivation1.java:157:66:157:69 | Salt | +| jca/KeyDerivation1.java:172:42:172:63 | Message | Source | jca/KeyDerivation1.java:169:30:169:44 | Parameter | +| jca/KeyDerivation1.java:172:66:172:69 | Salt | Source | jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:172:66:172:69 | Salt | Source | jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyDerivation1.java:174:22:174:49 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:173:65:173:72 | Constant | +| jca/KeyDerivation1.java:174:22:174:49 | KeyDerivation | Input | jca/KeyDerivation1.java:172:42:172:63 | Message | +| jca/KeyDerivation1.java:174:22:174:49 | KeyDerivation | Output | jca/KeyDerivation1.java:174:22:174:49 | Key | +| jca/KeyDerivation1.java:174:22:174:49 | KeyDerivation | Salt | jca/KeyDerivation1.java:172:66:172:69 | Salt | +| jca/KeyDerivation1.java:244:29:244:59 | Digest | Source | jca/KeyDerivation1.java:244:29:244:59 | Digest | +| jca/KeyDerivation1.java:244:29:244:59 | HashOperation | Algorithm | jca/KeyDerivation1.java:243:58:243:66 | HashAlgorithm | +| jca/KeyDerivation1.java:244:29:244:59 | HashOperation | Digest | jca/KeyDerivation1.java:244:29:244:59 | Digest | +| jca/KeyDerivation1.java:244:29:244:59 | HashOperation | Message | jca/KeyDerivation1.java:244:43:244:58 | Message | +| jca/KeyDerivation1.java:244:43:244:58 | Message | Source | jca/KeyDerivation1.java:242:45:242:56 | Parameter | +| jca/KeyDerivation1.java:249:70:249:88 | KeyOperationAlgorithm | Mode | jca/KeyDerivation1.java:249:70:249:88 | ModeOfOperation | +| jca/KeyDerivation1.java:249:70:249:88 | KeyOperationAlgorithm | Padding | jca/KeyDerivation1.java:249:70:249:88 | PaddingAlgorithm | +| jca/KeyDerivation1.java:250:55:250:57 | Key | Source | jca/KeyDerivation1.java:250:55:250:57 | Key | +| jca/KeyDerivation1.java:251:29:251:74 | EncryptOperation | Algorithm | jca/KeyDerivation1.java:249:70:249:88 | KeyOperationAlgorithm | +| jca/KeyDerivation1.java:251:29:251:74 | EncryptOperation | Input | jca/KeyDerivation1.java:251:44:251:73 | Message | +| jca/KeyDerivation1.java:251:29:251:74 | EncryptOperation | Key | jca/KeyDerivation1.java:250:55:250:57 | Key | +| jca/KeyDerivation1.java:251:29:251:74 | EncryptOperation | Nonce | jca/KeyDerivation1.java:251:29:251:74 | EncryptOperation | +| jca/KeyDerivation1.java:251:29:251:74 | EncryptOperation | Output | jca/KeyDerivation1.java:251:29:251:74 | KeyOperationOutput | +| jca/KeyDerivation1.java:251:44:251:73 | Message | Source | jca/KeyDerivation1.java:251:44:251:62 | Constant | +| jca/KeyDerivation1.java:309:54:309:75 | HMACAlgorithm | H | jca/KeyDerivation1.java:309:54:309:75 | HashAlgorithm | +| jca/KeyDerivation1.java:309:54:309:75 | KeyDerivationAlgorithm | PRF | jca/KeyDerivation1.java:309:54:309:75 | HMACAlgorithm | +| jca/KeyDerivation1.java:314:42:314:63 | Message | Source | jca/KeyDerivation1.java:302:37:302:51 | Parameter | +| jca/KeyDerivation1.java:314:66:314:69 | Salt | Source | jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:314:66:314:69 | Salt | Source | jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyDerivation1.java:316:26:316:53 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:309:25:309:76 | LocalData | +| jca/KeyDerivation1.java:316:26:316:53 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:309:54:309:75 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:316:26:316:53 | KeyDerivation | Input | jca/KeyDerivation1.java:314:42:314:63 | Message | +| jca/KeyDerivation1.java:316:26:316:53 | KeyDerivation | Output | jca/KeyDerivation1.java:316:26:316:53 | Key | +| jca/KeyDerivation1.java:316:26:316:53 | KeyDerivation | Salt | jca/KeyDerivation1.java:314:66:314:69 | Salt | +| jca/KeyDerivation1.java:333:42:333:63 | Message | Source | jca/KeyDerivation1.java:283:43:283:57 | Parameter | +| jca/KeyDerivation1.java:333:66:333:69 | Salt | Source | jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:333:66:333:69 | Salt | Source | jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyDerivation1.java:334:65:334:86 | HMACAlgorithm | H | jca/KeyDerivation1.java:334:65:334:86 | HashAlgorithm | +| jca/KeyDerivation1.java:334:65:334:86 | KeyDerivationAlgorithm | PRF | jca/KeyDerivation1.java:334:65:334:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:335:16:335:43 | KeyDerivation | Algorithm | jca/KeyDerivation1.java:334:65:334:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:335:16:335:43 | KeyDerivation | Input | jca/KeyDerivation1.java:333:42:333:63 | Message | +| jca/KeyDerivation1.java:335:16:335:43 | KeyDerivation | Output | jca/KeyDerivation1.java:335:16:335:43 | Key | +| jca/KeyDerivation1.java:335:16:335:43 | KeyDerivation | Salt | jca/KeyDerivation1.java:333:66:333:69 | Salt | +| jca/KeyDerivation1.java:345:36:345:47 | KeyOperationAlgorithm | Mode | jca/KeyDerivation1.java:345:36:345:47 | KeyOperationAlgorithm | +| jca/KeyDerivation1.java:345:36:345:47 | KeyOperationAlgorithm | Padding | jca/KeyDerivation1.java:345:36:345:47 | KeyOperationAlgorithm | +| jca/KeyDerivation1.java:347:19:347:27 | Key | Source | jca/KeyDerivation1.java:347:19:347:27 | Key | +| jca/KeyDerivation1.java:348:22:348:38 | MACOperation | Algorithm | jca/KeyDerivation1.java:345:36:345:47 | KeyOperationAlgorithm | +| jca/KeyDerivation1.java:348:22:348:38 | MACOperation | HashAlgorithm | jca/KeyDerivation1.java:348:22:348:38 | MACOperation | +| jca/KeyDerivation1.java:348:22:348:38 | MACOperation | Input | jca/KeyDerivation1.java:348:35:348:37 | Message | +| jca/KeyDerivation1.java:348:22:348:38 | MACOperation | Key | jca/KeyDerivation1.java:347:19:347:27 | Key | +| jca/KeyDerivation1.java:348:22:348:38 | MACOperation | Message | jca/KeyDerivation1.java:348:35:348:37 | Message | +| jca/KeyDerivation1.java:348:22:348:38 | MACOperation | Nonce | jca/KeyDerivation1.java:348:22:348:38 | MACOperation | +| jca/KeyDerivation1.java:348:22:348:38 | MACOperation | Output | jca/KeyDerivation1.java:348:22:348:38 | KeyOperationOutput | +| jca/KeyDerivation1.java:348:35:348:37 | Message | Source | jca/KeyDerivation1.java:269:32:269:41 | Parameter | +| jca/KeyDerivation1.java:348:35:348:37 | Message | Source | jca/KeyDerivation1.java:283:60:283:78 | Parameter | +| jca/KeyDerivation1.java:352:19:352:54 | Key | Source | jca/KeyDerivation1.java:352:19:352:54 | Key | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | Algorithm | jca/KeyDerivation1.java:345:36:345:47 | KeyOperationAlgorithm | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | HashAlgorithm | jca/KeyDerivation1.java:353:22:353:62 | MACOperation | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | Input | jca/KeyDerivation1.java:353:35:353:61 | Message | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | Key | jca/KeyDerivation1.java:347:19:347:27 | Key | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | Key | jca/KeyDerivation1.java:352:19:352:54 | Key | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | Message | jca/KeyDerivation1.java:353:35:353:61 | Message | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | Nonce | jca/KeyDerivation1.java:353:22:353:62 | MACOperation | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | Output | jca/KeyDerivation1.java:353:22:353:62 | KeyOperationOutput | +| jca/KeyDerivation1.java:353:35:353:61 | Message | Source | jca/KeyDerivation1.java:353:35:353:50 | Constant | +| jca/KeyEncapsulation.java:62:28:62:47 | KeyGeneration | Algorithm | jca/KeyEncapsulation.java:60:56:60:60 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:62:28:62:47 | KeyGeneration | Output | jca/KeyEncapsulation.java:62:28:62:47 | Key | +| jca/KeyEncapsulation.java:67:47:67:85 | KeyOperationAlgorithm | Mode | jca/KeyEncapsulation.java:67:47:67:85 | ModeOfOperation | +| jca/KeyEncapsulation.java:67:47:67:85 | KeyOperationAlgorithm | Padding | jca/KeyEncapsulation.java:67:47:67:85 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:67:47:67:85 | PaddingAlgorithm | MD | jca/KeyEncapsulation.java:67:47:67:85 | HashAlgorithm | +| jca/KeyEncapsulation.java:67:47:67:85 | PaddingAlgorithm | MGF1Hash | jca/KeyEncapsulation.java:67:47:67:85 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:68:45:68:50 | Key | Source | jca/KeyEncapsulation.java:209:25:209:48 | Key | +| jca/KeyEncapsulation.java:69:29:69:66 | EncryptOperation | Algorithm | jca/KeyEncapsulation.java:67:47:67:85 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:69:29:69:66 | EncryptOperation | Input | jca/KeyEncapsulation.java:69:47:69:65 | Message | +| jca/KeyEncapsulation.java:69:29:69:66 | EncryptOperation | Key | jca/KeyEncapsulation.java:68:45:68:50 | Key | +| jca/KeyEncapsulation.java:69:29:69:66 | EncryptOperation | Nonce | jca/KeyEncapsulation.java:69:29:69:66 | EncryptOperation | +| jca/KeyEncapsulation.java:69:29:69:66 | EncryptOperation | Output | jca/KeyEncapsulation.java:69:29:69:66 | KeyOperationOutput | +| jca/KeyEncapsulation.java:69:47:69:65 | Message | Source | jca/KeyEncapsulation.java:62:28:62:47 | Key | +| jca/KeyEncapsulation.java:73:47:73:65 | KeyOperationAlgorithm | Mode | jca/KeyEncapsulation.java:73:47:73:65 | ModeOfOperation | +| jca/KeyEncapsulation.java:73:47:73:65 | KeyOperationAlgorithm | Padding | jca/KeyEncapsulation.java:73:47:73:65 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:77:45:77:50 | Key | Source | jca/KeyEncapsulation.java:62:28:62:47 | Key | +| jca/KeyEncapsulation.java:77:53:77:59 | Nonce | Source | jca/KeyEncapsulation.java:75:9:75:40 | RandomNumberGeneration | +| jca/KeyEncapsulation.java:77:53:77:59 | Nonce | Source | jca/KeyEncapsulation.java:75:38:75:39 | RandomNumberGeneration | +| jca/KeyEncapsulation.java:78:29:78:80 | EncryptOperation | Algorithm | jca/KeyEncapsulation.java:73:47:73:65 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:78:29:78:80 | EncryptOperation | Input | jca/KeyEncapsulation.java:78:47:78:79 | Message | +| jca/KeyEncapsulation.java:78:29:78:80 | EncryptOperation | Key | jca/KeyEncapsulation.java:77:45:77:50 | Key | +| jca/KeyEncapsulation.java:78:29:78:80 | EncryptOperation | Nonce | jca/KeyEncapsulation.java:77:53:77:59 | Nonce | +| jca/KeyEncapsulation.java:78:29:78:80 | EncryptOperation | Output | jca/KeyEncapsulation.java:78:29:78:80 | KeyOperationOutput | +| jca/KeyEncapsulation.java:78:47:78:79 | Message | Source | jca/KeyEncapsulation.java:78:47:78:68 | Constant | +| jca/KeyEncapsulation.java:92:47:92:85 | KeyOperationAlgorithm | Mode | jca/KeyEncapsulation.java:92:47:92:85 | ModeOfOperation | +| jca/KeyEncapsulation.java:92:47:92:85 | KeyOperationAlgorithm | Padding | jca/KeyEncapsulation.java:92:47:92:85 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:92:47:92:85 | PaddingAlgorithm | MD | jca/KeyEncapsulation.java:92:47:92:85 | HashAlgorithm | +| jca/KeyEncapsulation.java:92:47:92:85 | PaddingAlgorithm | MGF1Hash | jca/KeyEncapsulation.java:92:47:92:85 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:93:45:93:51 | Key | Source | jca/KeyEncapsulation.java:91:37:91:54 | Parameter | +| jca/KeyEncapsulation.java:94:30:94:58 | DecryptOperation | Algorithm | jca/KeyEncapsulation.java:92:47:92:85 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:94:30:94:58 | DecryptOperation | Input | jca/KeyEncapsulation.java:94:48:94:57 | Message | +| jca/KeyEncapsulation.java:94:30:94:58 | DecryptOperation | Key | jca/KeyEncapsulation.java:93:45:93:51 | Key | +| jca/KeyEncapsulation.java:94:30:94:58 | DecryptOperation | Nonce | jca/KeyEncapsulation.java:94:30:94:58 | DecryptOperation | +| jca/KeyEncapsulation.java:94:30:94:58 | DecryptOperation | Output | jca/KeyEncapsulation.java:94:30:94:58 | KeyOperationOutput | +| jca/KeyEncapsulation.java:94:48:94:57 | Message | Source | jca/KeyEncapsulation.java:91:57:91:73 | Parameter | +| jca/KeyEncapsulation.java:118:31:118:51 | Key | Algorithm | jca/KeyEncapsulation.java:117:47:117:57 | EllipticCurve | +| jca/KeyEncapsulation.java:118:31:118:51 | KeyGeneration | Algorithm | jca/KeyEncapsulation.java:117:47:117:57 | EllipticCurve | +| jca/KeyEncapsulation.java:118:31:118:51 | KeyGeneration | Output | jca/KeyEncapsulation.java:118:31:118:51 | Key | +| jca/KeyEncapsulation.java:122:17:122:40 | Key | Source | jca/KeyEncapsulation.java:118:31:118:51 | Key | +| jca/KeyEncapsulation.java:123:20:123:24 | Key | Source | jca/KeyEncapsulation.java:215:24:215:46 | Key | +| jca/KeyEncapsulation.java:124:31:124:49 | KeyAgreementOperation | Algorithm | jca/KeyEncapsulation.java:121:52:121:57 | KeyAgreementAlgorithm | +| jca/KeyEncapsulation.java:124:31:124:49 | KeyAgreementOperation | Output | jca/KeyEncapsulation.java:124:31:124:49 | SharedSecret | +| jca/KeyEncapsulation.java:124:31:124:49 | KeyAgreementOperation | PeerKey | jca/KeyEncapsulation.java:123:20:123:24 | Key | +| jca/KeyEncapsulation.java:124:31:124:49 | KeyAgreementOperation | ServerKey | jca/KeyEncapsulation.java:122:17:122:40 | Key | +| jca/KeyEncapsulation.java:124:31:124:49 | SharedSecret | Source | jca/KeyEncapsulation.java:124:31:124:49 | SharedSecret | +| jca/KeyEncapsulation.java:133:47:133:65 | KeyOperationAlgorithm | Mode | jca/KeyEncapsulation.java:133:47:133:65 | ModeOfOperation | +| jca/KeyEncapsulation.java:133:47:133:65 | KeyOperationAlgorithm | Padding | jca/KeyEncapsulation.java:133:47:133:65 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:136:45:136:50 | Key | Source | jca/KeyEncapsulation.java:136:45:136:50 | Key | +| jca/KeyEncapsulation.java:136:53:136:81 | Nonce | Source | jca/KeyEncapsulation.java:135:9:135:40 | RandomNumberGeneration | +| jca/KeyEncapsulation.java:136:53:136:81 | Nonce | Source | jca/KeyEncapsulation.java:135:38:135:39 | RandomNumberGeneration | +| jca/KeyEncapsulation.java:137:29:137:73 | EncryptOperation | Algorithm | jca/KeyEncapsulation.java:133:47:133:65 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:137:29:137:73 | EncryptOperation | Input | jca/KeyEncapsulation.java:137:47:137:72 | Message | +| jca/KeyEncapsulation.java:137:29:137:73 | EncryptOperation | Key | jca/KeyEncapsulation.java:136:45:136:50 | Key | +| jca/KeyEncapsulation.java:137:29:137:73 | EncryptOperation | Nonce | jca/KeyEncapsulation.java:136:53:136:81 | Nonce | +| jca/KeyEncapsulation.java:137:29:137:73 | EncryptOperation | Output | jca/KeyEncapsulation.java:137:29:137:73 | KeyOperationOutput | +| jca/KeyEncapsulation.java:137:47:137:72 | Message | Source | jca/KeyEncapsulation.java:137:47:137:61 | Constant | +| jca/KeyEncapsulation.java:187:31:187:51 | Key | Algorithm | jca/KeyEncapsulation.java:186:47:186:57 | EllipticCurve | +| jca/KeyEncapsulation.java:187:31:187:51 | KeyGeneration | Algorithm | jca/KeyEncapsulation.java:186:47:186:57 | EllipticCurve | +| jca/KeyEncapsulation.java:187:31:187:51 | KeyGeneration | Output | jca/KeyEncapsulation.java:187:31:187:51 | Key | +| jca/KeyEncapsulation.java:189:17:189:40 | Key | Source | jca/KeyEncapsulation.java:187:31:187:51 | Key | +| jca/KeyEncapsulation.java:190:20:190:34 | Key | Source | jca/KeyEncapsulation.java:226:31:226:53 | Key | +| jca/KeyEncapsulation.java:191:31:191:49 | KeyAgreementOperation | Algorithm | jca/KeyEncapsulation.java:188:52:188:57 | KeyAgreementAlgorithm | +| jca/KeyEncapsulation.java:191:31:191:49 | KeyAgreementOperation | Output | jca/KeyEncapsulation.java:191:31:191:49 | SharedSecret | +| jca/KeyEncapsulation.java:191:31:191:49 | KeyAgreementOperation | PeerKey | jca/KeyEncapsulation.java:190:20:190:34 | Key | +| jca/KeyEncapsulation.java:191:31:191:49 | KeyAgreementOperation | ServerKey | jca/KeyEncapsulation.java:189:17:189:40 | Key | +| jca/KeyEncapsulation.java:191:31:191:49 | SharedSecret | Source | jca/KeyEncapsulation.java:191:31:191:49 | SharedSecret | +| jca/KeyEncapsulation.java:209:25:209:48 | Key | Algorithm | jca/KeyEncapsulation.java:207:64:207:68 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:209:25:209:48 | KeyGeneration | Algorithm | jca/KeyEncapsulation.java:207:64:207:68 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:209:25:209:48 | KeyGeneration | Output | jca/KeyEncapsulation.java:209:25:209:48 | Key | +| jca/KeyEncapsulation.java:215:24:215:46 | Key | Algorithm | jca/KeyEncapsulation.java:214:49:214:59 | EllipticCurve | +| jca/KeyEncapsulation.java:215:24:215:46 | KeyGeneration | Algorithm | jca/KeyEncapsulation.java:214:49:214:59 | EllipticCurve | +| jca/KeyEncapsulation.java:215:24:215:46 | KeyGeneration | Output | jca/KeyEncapsulation.java:215:24:215:46 | Key | +| jca/KeyEncapsulation.java:226:31:226:53 | Key | Algorithm | jca/KeyEncapsulation.java:214:49:214:59 | EllipticCurve | +| jca/KeyEncapsulation.java:226:31:226:53 | KeyGeneration | Algorithm | jca/KeyEncapsulation.java:214:49:214:59 | EllipticCurve | +| jca/KeyEncapsulation.java:226:31:226:53 | KeyGeneration | Output | jca/KeyEncapsulation.java:226:31:226:53 | Key | +| jca/KeyExchange.java:54:16:54:38 | Key | Algorithm | jca/KeyExchange.java:52:63:52:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:54:16:54:38 | KeyGeneration | Algorithm | jca/KeyExchange.java:52:63:52:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:54:16:54:38 | KeyGeneration | Output | jca/KeyExchange.java:54:16:54:38 | Key | +| jca/KeyExchange.java:70:16:70:38 | Key | Algorithm | jca/KeyExchange.java:67:63:67:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:70:16:70:38 | KeyGeneration | Algorithm | jca/KeyExchange.java:67:63:67:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:70:16:70:38 | KeyGeneration | Output | jca/KeyExchange.java:70:16:70:38 | Key | +| jca/KeyExchange.java:85:16:85:38 | Key | Algorithm | jca/KeyExchange.java:83:63:83:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:85:16:85:38 | KeyGeneration | Algorithm | jca/KeyExchange.java:83:63:83:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:85:16:85:38 | KeyGeneration | Output | jca/KeyExchange.java:85:16:85:38 | Key | +| jca/KeyExchange.java:100:17:100:26 | Key | Source | jca/KeyExchange.java:54:16:54:38 | Key | +| jca/KeyExchange.java:100:17:100:26 | Key | Source | jca/KeyExchange.java:70:16:70:38 | Key | +| jca/KeyExchange.java:100:17:100:26 | Key | Source | jca/KeyExchange.java:85:16:85:38 | Key | +| jca/KeyExchange.java:101:20:101:28 | Key | Source | jca/KeyExchange.java:54:16:54:38 | Key | +| jca/KeyExchange.java:101:20:101:28 | Key | Source | jca/KeyExchange.java:70:16:70:38 | Key | +| jca/KeyExchange.java:101:20:101:28 | Key | Source | jca/KeyExchange.java:85:16:85:38 | Key | +| jca/KeyExchange.java:102:16:102:34 | KeyAgreementOperation | Algorithm | jca/KeyExchange.java:99:52:99:55 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:102:16:102:34 | KeyAgreementOperation | Output | jca/KeyExchange.java:102:16:102:34 | SharedSecret | +| jca/KeyExchange.java:102:16:102:34 | KeyAgreementOperation | PeerKey | jca/KeyExchange.java:101:20:101:28 | Key | +| jca/KeyExchange.java:102:16:102:34 | KeyAgreementOperation | ServerKey | jca/KeyExchange.java:100:17:100:26 | Key | +| jca/KeyExchange.java:102:16:102:34 | SharedSecret | Source | jca/KeyExchange.java:102:16:102:34 | SharedSecret | +| jca/KeyExchange.java:122:16:122:38 | Key | Algorithm | jca/KeyExchange.java:121:49:121:59 | EllipticCurve | +| jca/KeyExchange.java:122:16:122:38 | KeyGeneration | Algorithm | jca/KeyExchange.java:121:49:121:59 | EllipticCurve | +| jca/KeyExchange.java:122:16:122:38 | KeyGeneration | Output | jca/KeyExchange.java:122:16:122:38 | Key | +| jca/KeyExchange.java:137:17:137:26 | Key | Source | jca/KeyExchange.java:122:16:122:38 | Key | +| jca/KeyExchange.java:138:20:138:28 | Key | Source | jca/KeyExchange.java:122:16:122:38 | Key | +| jca/KeyExchange.java:139:16:139:34 | KeyAgreementOperation | Algorithm | jca/KeyExchange.java:136:52:136:57 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:139:16:139:34 | KeyAgreementOperation | Output | jca/KeyExchange.java:139:16:139:34 | SharedSecret | +| jca/KeyExchange.java:139:16:139:34 | KeyAgreementOperation | PeerKey | jca/KeyExchange.java:138:20:138:28 | Key | +| jca/KeyExchange.java:139:16:139:34 | KeyAgreementOperation | ServerKey | jca/KeyExchange.java:137:17:137:26 | Key | +| jca/KeyExchange.java:139:16:139:34 | SharedSecret | Source | jca/KeyExchange.java:139:16:139:34 | SharedSecret | +| jca/KeyExchange.java:159:16:159:36 | Key | Algorithm | jca/KeyExchange.java:156:61:156:68 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:159:16:159:36 | KeyGeneration | Algorithm | jca/KeyExchange.java:156:61:156:68 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:159:16:159:36 | KeyGeneration | Output | jca/KeyExchange.java:159:16:159:36 | Key | +| jca/KeyExchange.java:174:17:174:26 | Key | Source | jca/KeyExchange.java:159:16:159:36 | Key | +| jca/KeyExchange.java:175:20:175:28 | Key | Source | jca/KeyExchange.java:159:16:159:36 | Key | +| jca/KeyExchange.java:176:16:176:34 | KeyAgreementOperation | Algorithm | jca/KeyExchange.java:173:52:173:59 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:176:16:176:34 | KeyAgreementOperation | Output | jca/KeyExchange.java:176:16:176:34 | SharedSecret | +| jca/KeyExchange.java:176:16:176:34 | KeyAgreementOperation | PeerKey | jca/KeyExchange.java:175:20:175:28 | Key | +| jca/KeyExchange.java:176:16:176:34 | KeyAgreementOperation | ServerKey | jca/KeyExchange.java:174:17:174:26 | Key | +| jca/KeyExchange.java:176:16:176:34 | SharedSecret | Source | jca/KeyExchange.java:176:16:176:34 | SharedSecret | +| jca/KeyExchange.java:196:16:196:36 | Key | Algorithm | jca/KeyExchange.java:193:61:193:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:196:16:196:36 | KeyGeneration | Algorithm | jca/KeyExchange.java:193:61:193:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:196:16:196:36 | KeyGeneration | Output | jca/KeyExchange.java:196:16:196:36 | Key | +| jca/KeyExchange.java:211:17:211:26 | Key | Source | jca/KeyExchange.java:196:16:196:36 | Key | +| jca/KeyExchange.java:212:20:212:28 | Key | Source | jca/KeyExchange.java:196:16:196:36 | Key | +| jca/KeyExchange.java:213:16:213:34 | KeyAgreementOperation | Algorithm | jca/KeyExchange.java:210:52:210:57 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:213:16:213:34 | KeyAgreementOperation | Output | jca/KeyExchange.java:213:16:213:34 | SharedSecret | +| jca/KeyExchange.java:213:16:213:34 | KeyAgreementOperation | PeerKey | jca/KeyExchange.java:212:20:212:28 | Key | +| jca/KeyExchange.java:213:16:213:34 | KeyAgreementOperation | ServerKey | jca/KeyExchange.java:211:17:211:26 | Key | +| jca/KeyExchange.java:213:16:213:34 | SharedSecret | Source | jca/KeyExchange.java:213:16:213:34 | SharedSecret | +| jca/MACOperation.java:60:35:60:46 | KeyOperationAlgorithm | Mode | jca/MACOperation.java:60:35:60:46 | KeyOperationAlgorithm | +| jca/MACOperation.java:60:35:60:46 | KeyOperationAlgorithm | Padding | jca/MACOperation.java:60:35:60:46 | KeyOperationAlgorithm | +| jca/MACOperation.java:62:18:62:26 | Key | Source | jca/MACOperation.java:59:52:59:61 | Parameter | +| jca/MACOperation.java:63:16:63:46 | MACOperation | Algorithm | jca/MACOperation.java:60:35:60:46 | KeyOperationAlgorithm | +| jca/MACOperation.java:63:16:63:46 | MACOperation | HashAlgorithm | jca/MACOperation.java:63:16:63:46 | MACOperation | +| jca/MACOperation.java:63:16:63:46 | MACOperation | Input | jca/MACOperation.java:63:28:63:45 | Message | +| jca/MACOperation.java:63:16:63:46 | MACOperation | Key | jca/MACOperation.java:62:18:62:26 | Key | +| jca/MACOperation.java:63:16:63:46 | MACOperation | Message | jca/MACOperation.java:63:28:63:45 | Message | +| jca/MACOperation.java:63:16:63:46 | MACOperation | Nonce | jca/MACOperation.java:63:16:63:46 | MACOperation | +| jca/MACOperation.java:63:16:63:46 | MACOperation | Output | jca/MACOperation.java:63:16:63:46 | KeyOperationOutput | +| jca/MACOperation.java:63:28:63:45 | Message | Source | jca/MACOperation.java:59:36:59:49 | Parameter | +| jca/MACOperation.java:71:35:71:48 | KeyOperationAlgorithm | Mode | jca/MACOperation.java:71:35:71:48 | KeyOperationAlgorithm | +| jca/MACOperation.java:71:35:71:48 | KeyOperationAlgorithm | Padding | jca/MACOperation.java:71:35:71:48 | KeyOperationAlgorithm | +| jca/MACOperation.java:73:18:73:26 | Key | Source | jca/MACOperation.java:70:50:70:59 | Parameter | +| jca/MACOperation.java:74:16:74:46 | MACOperation | Algorithm | jca/MACOperation.java:71:35:71:48 | KeyOperationAlgorithm | +| jca/MACOperation.java:74:16:74:46 | MACOperation | HashAlgorithm | jca/MACOperation.java:74:16:74:46 | MACOperation | +| jca/MACOperation.java:74:16:74:46 | MACOperation | Input | jca/MACOperation.java:74:28:74:45 | Message | +| jca/MACOperation.java:74:16:74:46 | MACOperation | Key | jca/MACOperation.java:73:18:73:26 | Key | +| jca/MACOperation.java:74:16:74:46 | MACOperation | Message | jca/MACOperation.java:74:28:74:45 | Message | +| jca/MACOperation.java:74:16:74:46 | MACOperation | Nonce | jca/MACOperation.java:74:16:74:46 | MACOperation | +| jca/MACOperation.java:74:16:74:46 | MACOperation | Output | jca/MACOperation.java:74:16:74:46 | KeyOperationOutput | +| jca/MACOperation.java:74:28:74:45 | Message | Source | jca/MACOperation.java:70:34:70:47 | Parameter | +| jca/MACOperation.java:82:35:82:44 | KeyOperationAlgorithm | Mode | jca/MACOperation.java:82:35:82:44 | KeyOperationAlgorithm | +| jca/MACOperation.java:82:35:82:44 | KeyOperationAlgorithm | Padding | jca/MACOperation.java:82:35:82:44 | KeyOperationAlgorithm | +| jca/MACOperation.java:84:18:84:26 | Key | Source | jca/MACOperation.java:81:50:81:59 | Parameter | +| jca/MACOperation.java:85:16:85:46 | MACOperation | Algorithm | jca/MACOperation.java:82:35:82:44 | KeyOperationAlgorithm | +| jca/MACOperation.java:85:16:85:46 | MACOperation | HashAlgorithm | jca/MACOperation.java:85:16:85:46 | MACOperation | +| jca/MACOperation.java:85:16:85:46 | MACOperation | Input | jca/MACOperation.java:85:28:85:45 | Message | +| jca/MACOperation.java:85:16:85:46 | MACOperation | Key | jca/MACOperation.java:84:18:84:26 | Key | +| jca/MACOperation.java:85:16:85:46 | MACOperation | Message | jca/MACOperation.java:85:28:85:45 | Message | +| jca/MACOperation.java:85:16:85:46 | MACOperation | Nonce | jca/MACOperation.java:85:16:85:46 | MACOperation | +| jca/MACOperation.java:85:16:85:46 | MACOperation | Output | jca/MACOperation.java:85:16:85:46 | KeyOperationOutput | +| jca/MACOperation.java:85:28:85:45 | Message | Source | jca/MACOperation.java:81:34:81:47 | Parameter | +| jca/MACOperation.java:94:35:94:40 | KeyOperationAlgorithm | Mode | jca/MACOperation.java:94:35:94:40 | KeyOperationAlgorithm | +| jca/MACOperation.java:94:35:94:40 | KeyOperationAlgorithm | Padding | jca/MACOperation.java:94:35:94:40 | KeyOperationAlgorithm | +| jca/MACOperation.java:98:18:98:26 | Key | Source | jca/MACOperation.java:92:46:92:55 | Parameter | +| jca/MACOperation.java:99:16:99:46 | MACOperation | Algorithm | jca/MACOperation.java:94:35:94:40 | KeyOperationAlgorithm | +| jca/MACOperation.java:99:16:99:46 | MACOperation | HashAlgorithm | jca/MACOperation.java:99:16:99:46 | MACOperation | +| jca/MACOperation.java:99:16:99:46 | MACOperation | Input | jca/MACOperation.java:99:28:99:45 | Message | +| jca/MACOperation.java:99:16:99:46 | MACOperation | Key | jca/MACOperation.java:98:18:98:26 | Key | +| jca/MACOperation.java:99:16:99:46 | MACOperation | Message | jca/MACOperation.java:99:28:99:45 | Message | +| jca/MACOperation.java:99:16:99:46 | MACOperation | Nonce | jca/MACOperation.java:99:16:99:46 | MACOperation | +| jca/MACOperation.java:99:16:99:46 | MACOperation | Output | jca/MACOperation.java:99:16:99:46 | KeyOperationOutput | +| jca/MACOperation.java:99:28:99:45 | Message | Source | jca/MACOperation.java:92:30:92:43 | Parameter | +| jca/MACOperation.java:109:18:109:26 | Key | Source | jca/MACOperation.java:106:46:106:55 | Parameter | +| jca/MACOperation.java:110:16:110:46 | MACOperation | Algorithm | jca/MACOperation.java:107:35:107:43 | Constant | +| jca/MACOperation.java:110:16:110:46 | MACOperation | HashAlgorithm | jca/MACOperation.java:110:16:110:46 | MACOperation | +| jca/MACOperation.java:110:16:110:46 | MACOperation | Input | jca/MACOperation.java:110:28:110:45 | Message | +| jca/MACOperation.java:110:16:110:46 | MACOperation | Key | jca/MACOperation.java:109:18:109:26 | Key | +| jca/MACOperation.java:110:16:110:46 | MACOperation | Message | jca/MACOperation.java:110:28:110:45 | Message | +| jca/MACOperation.java:110:16:110:46 | MACOperation | Nonce | jca/MACOperation.java:110:16:110:46 | MACOperation | +| jca/MACOperation.java:110:16:110:46 | MACOperation | Output | jca/MACOperation.java:110:16:110:46 | KeyOperationOutput | +| jca/MACOperation.java:110:28:110:45 | Message | Source | jca/MACOperation.java:106:30:106:43 | Parameter | +| jca/MACOperation.java:118:35:118:44 | KeyOperationAlgorithm | Mode | jca/MACOperation.java:118:35:118:44 | KeyOperationAlgorithm | +| jca/MACOperation.java:118:35:118:44 | KeyOperationAlgorithm | Padding | jca/MACOperation.java:118:35:118:44 | KeyOperationAlgorithm | +| jca/MACOperation.java:120:18:120:26 | Key | Source | jca/MACOperation.java:117:52:117:61 | Parameter | +| jca/MACOperation.java:121:16:121:46 | MACOperation | Algorithm | jca/MACOperation.java:118:35:118:44 | KeyOperationAlgorithm | +| jca/MACOperation.java:121:16:121:46 | MACOperation | HashAlgorithm | jca/MACOperation.java:121:16:121:46 | MACOperation | +| jca/MACOperation.java:121:16:121:46 | MACOperation | Input | jca/MACOperation.java:121:28:121:45 | Message | +| jca/MACOperation.java:121:16:121:46 | MACOperation | Key | jca/MACOperation.java:120:18:120:26 | Key | +| jca/MACOperation.java:121:16:121:46 | MACOperation | Message | jca/MACOperation.java:121:28:121:45 | Message | +| jca/MACOperation.java:121:16:121:46 | MACOperation | Nonce | jca/MACOperation.java:121:16:121:46 | MACOperation | +| jca/MACOperation.java:121:16:121:46 | MACOperation | Output | jca/MACOperation.java:121:16:121:46 | KeyOperationOutput | +| jca/MACOperation.java:121:28:121:45 | Message | Source | jca/MACOperation.java:117:36:117:49 | Parameter | +| jca/MACOperation.java:136:44:136:62 | KeyOperationAlgorithm | Mode | jca/MACOperation.java:136:44:136:62 | ModeOfOperation | +| jca/MACOperation.java:136:44:136:62 | KeyOperationAlgorithm | Padding | jca/MACOperation.java:136:44:136:62 | PaddingAlgorithm | +| jca/MACOperation.java:137:42:137:44 | Key | Source | jca/MACOperation.java:133:34:133:49 | Parameter | +| jca/MACOperation.java:138:32:138:74 | EncryptOperation | Algorithm | jca/MACOperation.java:136:44:136:62 | KeyOperationAlgorithm | +| jca/MACOperation.java:138:32:138:74 | EncryptOperation | Input | jca/MACOperation.java:138:47:138:73 | Message | +| jca/MACOperation.java:138:32:138:74 | EncryptOperation | Key | jca/MACOperation.java:137:42:137:44 | Key | +| jca/MACOperation.java:138:32:138:74 | EncryptOperation | Nonce | jca/MACOperation.java:138:32:138:74 | EncryptOperation | +| jca/MACOperation.java:138:32:138:74 | EncryptOperation | Output | jca/MACOperation.java:138:32:138:74 | KeyOperationOutput | +| jca/MACOperation.java:138:47:138:73 | Message | Source | jca/MACOperation.java:138:47:138:62 | Constant | +| jca/MACOperation.java:170:42:170:68 | Message | Source | jca/MACOperation.java:166:47:166:62 | Parameter | +| jca/MACOperation.java:170:71:170:74 | Salt | Source | jca/MACOperation.java:246:9:246:42 | RandomNumberGeneration | +| jca/MACOperation.java:170:71:170:74 | Salt | Source | jca/MACOperation.java:246:38:246:41 | RandomNumberGeneration | +| jca/MACOperation.java:171:65:171:86 | HMACAlgorithm | H | jca/MACOperation.java:171:65:171:86 | HashAlgorithm | +| jca/MACOperation.java:171:65:171:86 | KeyDerivationAlgorithm | PRF | jca/MACOperation.java:171:65:171:86 | HMACAlgorithm | +| jca/MACOperation.java:172:30:172:57 | KeyDerivation | Algorithm | jca/MACOperation.java:171:65:171:86 | KeyDerivationAlgorithm | +| jca/MACOperation.java:172:30:172:57 | KeyDerivation | Input | jca/MACOperation.java:170:42:170:68 | Message | +| jca/MACOperation.java:172:30:172:57 | KeyDerivation | Output | jca/MACOperation.java:172:30:172:57 | Key | +| jca/MACOperation.java:172:30:172:57 | KeyDerivation | Salt | jca/MACOperation.java:170:71:170:74 | Salt | +| jca/MACOperation.java:180:44:180:62 | KeyOperationAlgorithm | Mode | jca/MACOperation.java:180:44:180:62 | ModeOfOperation | +| jca/MACOperation.java:180:44:180:62 | KeyOperationAlgorithm | Padding | jca/MACOperation.java:180:44:180:62 | PaddingAlgorithm | +| jca/MACOperation.java:181:42:181:54 | Key | Source | jca/MACOperation.java:181:42:181:54 | Key | +| jca/MACOperation.java:182:29:182:78 | EncryptOperation | Algorithm | jca/MACOperation.java:180:44:180:62 | KeyOperationAlgorithm | +| jca/MACOperation.java:182:29:182:78 | EncryptOperation | Input | jca/MACOperation.java:182:44:182:77 | Message | +| jca/MACOperation.java:182:29:182:78 | EncryptOperation | Key | jca/MACOperation.java:181:42:181:54 | Key | +| jca/MACOperation.java:182:29:182:78 | EncryptOperation | Nonce | jca/MACOperation.java:182:29:182:78 | EncryptOperation | +| jca/MACOperation.java:182:29:182:78 | EncryptOperation | Output | jca/MACOperation.java:182:29:182:78 | KeyOperationOutput | +| jca/MACOperation.java:182:44:182:77 | Message | Source | jca/MACOperation.java:182:44:182:66 | Constant | +| jca/MACOperation.java:185:35:185:46 | KeyOperationAlgorithm | Mode | jca/MACOperation.java:185:35:185:46 | KeyOperationAlgorithm | +| jca/MACOperation.java:185:35:185:46 | KeyOperationAlgorithm | Padding | jca/MACOperation.java:185:35:185:46 | KeyOperationAlgorithm | +| jca/MACOperation.java:186:18:186:30 | Key | Source | jca/MACOperation.java:186:18:186:30 | Key | +| jca/MACOperation.java:187:30:187:52 | MACOperation | Algorithm | jca/MACOperation.java:185:35:185:46 | KeyOperationAlgorithm | +| jca/MACOperation.java:187:30:187:52 | MACOperation | HashAlgorithm | jca/MACOperation.java:187:30:187:52 | MACOperation | +| jca/MACOperation.java:187:30:187:52 | MACOperation | Input | jca/MACOperation.java:187:42:187:51 | Message | +| jca/MACOperation.java:187:30:187:52 | MACOperation | Key | jca/MACOperation.java:186:18:186:30 | Key | +| jca/MACOperation.java:187:30:187:52 | MACOperation | Message | jca/MACOperation.java:187:42:187:51 | Message | +| jca/MACOperation.java:187:30:187:52 | MACOperation | Nonce | jca/MACOperation.java:187:30:187:52 | MACOperation | +| jca/MACOperation.java:187:30:187:52 | MACOperation | Output | jca/MACOperation.java:187:30:187:52 | KeyOperationOutput | +| jca/MACOperation.java:187:42:187:51 | Message | Source | jca/MACOperation.java:182:29:182:78 | KeyOperationOutput | +| jca/MACOperation.java:216:44:216:62 | KeyOperationAlgorithm | Mode | jca/MACOperation.java:216:44:216:62 | ModeOfOperation | +| jca/MACOperation.java:216:44:216:62 | KeyOperationAlgorithm | Padding | jca/MACOperation.java:216:44:216:62 | PaddingAlgorithm | +| jca/MACOperation.java:218:42:218:44 | Key | Source | jca/MACOperation.java:234:16:234:35 | Key | +| jca/MACOperation.java:219:32:219:51 | EncryptOperation | Algorithm | jca/MACOperation.java:216:44:216:62 | KeyOperationAlgorithm | +| jca/MACOperation.java:219:32:219:51 | EncryptOperation | Input | jca/MACOperation.java:219:47:219:50 | Message | +| jca/MACOperation.java:219:32:219:51 | EncryptOperation | Key | jca/MACOperation.java:218:42:218:44 | Key | +| jca/MACOperation.java:219:32:219:51 | EncryptOperation | Nonce | jca/MACOperation.java:219:32:219:51 | EncryptOperation | +| jca/MACOperation.java:219:32:219:51 | EncryptOperation | Output | jca/MACOperation.java:219:32:219:51 | KeyOperationOutput | +| jca/MACOperation.java:219:47:219:50 | Message | Source | jca/MACOperation.java:150:36:150:51 | Parameter | +| jca/MACOperation.java:234:16:234:35 | KeyGeneration | Algorithm | jca/MACOperation.java:232:56:232:60 | KeyOperationAlgorithm | +| jca/MACOperation.java:234:16:234:35 | KeyGeneration | Output | jca/MACOperation.java:234:16:234:35 | Key | +| jca/Nonce.java:24:35:24:46 | KeyOperationAlgorithm | Mode | jca/Nonce.java:24:35:24:46 | KeyOperationAlgorithm | +| jca/Nonce.java:24:35:24:46 | KeyOperationAlgorithm | Padding | jca/Nonce.java:24:35:24:46 | KeyOperationAlgorithm | +| jca/Nonce.java:25:18:25:20 | Key | Source | jca/Nonce.java:93:16:93:35 | Key | +| jca/Nonce.java:27:28:27:69 | MACOperation | Algorithm | jca/Nonce.java:24:35:24:46 | KeyOperationAlgorithm | +| jca/Nonce.java:27:28:27:69 | MACOperation | HashAlgorithm | jca/Nonce.java:27:28:27:69 | MACOperation | +| jca/Nonce.java:27:28:27:69 | MACOperation | Input | jca/Nonce.java:27:40:27:68 | Message | +| jca/Nonce.java:27:28:27:69 | MACOperation | Key | jca/Nonce.java:25:18:25:20 | Key | +| jca/Nonce.java:27:28:27:69 | MACOperation | Message | jca/Nonce.java:27:40:27:68 | Message | +| jca/Nonce.java:27:28:27:69 | MACOperation | Nonce | jca/Nonce.java:27:28:27:69 | MACOperation | +| jca/Nonce.java:27:28:27:69 | MACOperation | Output | jca/Nonce.java:27:28:27:69 | KeyOperationOutput | +| jca/Nonce.java:27:40:27:68 | Message | Source | jca/Nonce.java:27:40:27:57 | Constant | +| jca/Nonce.java:37:35:37:46 | KeyOperationAlgorithm | Mode | jca/Nonce.java:37:35:37:46 | KeyOperationAlgorithm | +| jca/Nonce.java:37:35:37:46 | KeyOperationAlgorithm | Padding | jca/Nonce.java:37:35:37:46 | KeyOperationAlgorithm | +| jca/Nonce.java:38:18:38:20 | Key | Source | jca/Nonce.java:93:16:93:35 | Key | +| jca/Nonce.java:40:28:40:67 | MACOperation | Algorithm | jca/Nonce.java:37:35:37:46 | KeyOperationAlgorithm | +| jca/Nonce.java:40:28:40:67 | MACOperation | HashAlgorithm | jca/Nonce.java:40:28:40:67 | MACOperation | +| jca/Nonce.java:40:28:40:67 | MACOperation | Input | jca/Nonce.java:40:40:40:66 | Message | +| jca/Nonce.java:40:28:40:67 | MACOperation | Key | jca/Nonce.java:38:18:38:20 | Key | +| jca/Nonce.java:40:28:40:67 | MACOperation | Message | jca/Nonce.java:40:40:40:66 | Message | +| jca/Nonce.java:40:28:40:67 | MACOperation | Nonce | jca/Nonce.java:40:28:40:67 | MACOperation | +| jca/Nonce.java:40:28:40:67 | MACOperation | Output | jca/Nonce.java:40:28:40:67 | KeyOperationOutput | +| jca/Nonce.java:40:40:40:66 | Message | Source | jca/Nonce.java:40:40:40:55 | Constant | +| jca/Nonce.java:50:44:50:62 | KeyOperationAlgorithm | Mode | jca/Nonce.java:50:44:50:62 | ModeOfOperation | +| jca/Nonce.java:50:44:50:62 | KeyOperationAlgorithm | Padding | jca/Nonce.java:50:44:50:62 | PaddingAlgorithm | +| jca/Nonce.java:51:42:51:44 | Key | Source | jca/Nonce.java:47:39:47:51 | Parameter | +| jca/Nonce.java:51:47:51:53 | Nonce | Source | jca/Nonce.java:112:16:112:33 | Constant | +| jca/Nonce.java:52:29:52:53 | EncryptOperation | Algorithm | jca/Nonce.java:50:44:50:62 | KeyOperationAlgorithm | +| jca/Nonce.java:52:29:52:53 | EncryptOperation | Input | jca/Nonce.java:52:44:52:52 | Message | +| jca/Nonce.java:52:29:52:53 | EncryptOperation | Key | jca/Nonce.java:51:42:51:44 | Key | +| jca/Nonce.java:52:29:52:53 | EncryptOperation | Nonce | jca/Nonce.java:51:47:51:53 | Nonce | +| jca/Nonce.java:52:29:52:53 | EncryptOperation | Output | jca/Nonce.java:52:29:52:53 | KeyOperationOutput | +| jca/Nonce.java:52:44:52:52 | Message | Source | jca/Nonce.java:47:54:47:69 | Parameter | +| jca/Nonce.java:61:44:61:62 | KeyOperationAlgorithm | Mode | jca/Nonce.java:61:44:61:62 | ModeOfOperation | +| jca/Nonce.java:61:44:61:62 | KeyOperationAlgorithm | Padding | jca/Nonce.java:61:44:61:62 | PaddingAlgorithm | +| jca/Nonce.java:62:42:62:44 | Key | Source | jca/Nonce.java:58:37:58:49 | Parameter | +| jca/Nonce.java:62:47:62:53 | Nonce | Source | jca/Nonce.java:98:9:98:43 | RandomNumberGeneration | +| jca/Nonce.java:62:47:62:53 | Nonce | Source | jca/Nonce.java:98:38:98:42 | RandomNumberGeneration | +| jca/Nonce.java:63:29:63:53 | EncryptOperation | Algorithm | jca/Nonce.java:61:44:61:62 | KeyOperationAlgorithm | +| jca/Nonce.java:63:29:63:53 | EncryptOperation | Input | jca/Nonce.java:63:44:63:52 | Message | +| jca/Nonce.java:63:29:63:53 | EncryptOperation | Key | jca/Nonce.java:62:42:62:44 | Key | +| jca/Nonce.java:63:29:63:53 | EncryptOperation | Nonce | jca/Nonce.java:62:47:62:53 | Nonce | +| jca/Nonce.java:63:29:63:53 | EncryptOperation | Output | jca/Nonce.java:63:29:63:53 | KeyOperationOutput | +| jca/Nonce.java:63:44:63:52 | Message | Source | jca/Nonce.java:58:52:58:67 | Parameter | +| jca/Nonce.java:70:53:70:64 | KeyOperationAlgorithm | Mode | jca/Nonce.java:70:53:70:64 | KeyOperationAlgorithm | +| jca/Nonce.java:70:53:70:64 | KeyOperationAlgorithm | Padding | jca/Nonce.java:70:53:70:64 | KeyOperationAlgorithm | +| jca/Nonce.java:78:18:78:20 | Key | Source | jca/Nonce.java:93:16:93:35 | Key | +| jca/Nonce.java:80:28:80:67 | MACOperation | Algorithm | jca/Nonce.java:70:53:70:64 | KeyOperationAlgorithm | +| jca/Nonce.java:80:28:80:67 | MACOperation | HashAlgorithm | jca/Nonce.java:80:28:80:67 | MACOperation | +| jca/Nonce.java:80:28:80:67 | MACOperation | Input | jca/Nonce.java:80:40:80:66 | Message | +| jca/Nonce.java:80:28:80:67 | MACOperation | Key | jca/Nonce.java:78:18:78:20 | Key | +| jca/Nonce.java:80:28:80:67 | MACOperation | Message | jca/Nonce.java:80:40:80:66 | Message | +| jca/Nonce.java:80:28:80:67 | MACOperation | Nonce | jca/Nonce.java:80:28:80:67 | MACOperation | +| jca/Nonce.java:80:28:80:67 | MACOperation | Output | jca/Nonce.java:80:28:80:67 | KeyOperationOutput | +| jca/Nonce.java:80:40:80:66 | Message | Source | jca/Nonce.java:80:40:80:55 | Constant | +| jca/Nonce.java:93:16:93:35 | KeyGeneration | Algorithm | jca/Nonce.java:92:56:92:67 | Constant | +| jca/Nonce.java:93:16:93:35 | KeyGeneration | Output | jca/Nonce.java:93:16:93:35 | Key | +| jca/PrngTest.java:154:16:154:35 | KeyGeneration | Algorithm | jca/PrngTest.java:152:56:152:60 | KeyOperationAlgorithm | +| jca/PrngTest.java:154:16:154:35 | KeyGeneration | Output | jca/PrngTest.java:154:16:154:35 | Key | +| jca/SignEncryptCombinations.java:53:16:53:38 | Key | Algorithm | jca/SignEncryptCombinations.java:52:49:52:59 | EllipticCurve | +| jca/SignEncryptCombinations.java:53:16:53:38 | KeyGeneration | Algorithm | jca/SignEncryptCombinations.java:52:49:52:59 | EllipticCurve | +| jca/SignEncryptCombinations.java:53:16:53:38 | KeyGeneration | Output | jca/SignEncryptCombinations.java:53:16:53:38 | Key | +| jca/SignEncryptCombinations.java:61:53:61:69 | KeyOperationAlgorithm | Mode | jca/SignEncryptCombinations.java:61:53:61:69 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:61:53:61:69 | KeyOperationAlgorithm | Padding | jca/SignEncryptCombinations.java:61:53:61:69 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:62:28:62:34 | Key | Source | jca/SignEncryptCombinations.java:53:16:53:38 | Key | +| jca/SignEncryptCombinations.java:63:26:63:29 | Message | Source | jca/SignEncryptCombinations.java:335:26:335:47 | Constant | +| jca/SignEncryptCombinations.java:64:16:64:31 | SignOperation | Algorithm | jca/SignEncryptCombinations.java:61:53:61:69 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:64:16:64:31 | SignOperation | HashAlgorithm | jca/SignEncryptCombinations.java:61:53:61:69 | HashAlgorithm | +| jca/SignEncryptCombinations.java:64:16:64:31 | SignOperation | Input | jca/SignEncryptCombinations.java:63:26:63:29 | Message | +| jca/SignEncryptCombinations.java:64:16:64:31 | SignOperation | Key | jca/SignEncryptCombinations.java:62:28:62:34 | Key | +| jca/SignEncryptCombinations.java:64:16:64:31 | SignOperation | Output | jca/SignEncryptCombinations.java:64:16:64:31 | SignatureOutput | +| jca/SignEncryptCombinations.java:68:53:68:69 | KeyOperationAlgorithm | Mode | jca/SignEncryptCombinations.java:68:53:68:69 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:68:53:68:69 | KeyOperationAlgorithm | Padding | jca/SignEncryptCombinations.java:68:53:68:69 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:69:30:69:35 | Key | Source | jca/SignEncryptCombinations.java:53:16:53:38 | Key | +| jca/SignEncryptCombinations.java:70:26:70:29 | Message | Source | jca/SignEncryptCombinations.java:335:26:335:47 | Constant | +| jca/SignEncryptCombinations.java:71:16:71:47 | VerifyOperation | Algorithm | jca/SignEncryptCombinations.java:68:53:68:69 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:71:16:71:47 | VerifyOperation | HashAlgorithm | jca/SignEncryptCombinations.java:68:53:68:69 | HashAlgorithm | +| jca/SignEncryptCombinations.java:71:16:71:47 | VerifyOperation | Input | jca/SignEncryptCombinations.java:70:26:70:29 | Message | +| jca/SignEncryptCombinations.java:71:16:71:47 | VerifyOperation | Key | jca/SignEncryptCombinations.java:69:30:69:35 | Key | +| jca/SignEncryptCombinations.java:71:16:71:47 | VerifyOperation | Signature | jca/SignEncryptCombinations.java:71:33:71:46 | SignatureInput | +| jca/SignEncryptCombinations.java:71:33:71:46 | SignatureInput | Source | jca/SignEncryptCombinations.java:113:16:113:41 | KeyOperationOutput | +| jca/SignEncryptCombinations.java:84:16:84:31 | KeyGeneration | Algorithm | jca/SignEncryptCombinations.java:82:52:82:56 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:84:16:84:31 | KeyGeneration | Output | jca/SignEncryptCombinations.java:84:16:84:31 | Key | +| jca/SignEncryptCombinations.java:92:44:92:62 | KeyOperationAlgorithm | Mode | jca/SignEncryptCombinations.java:92:44:92:62 | ModeOfOperation | +| jca/SignEncryptCombinations.java:92:44:92:62 | KeyOperationAlgorithm | Padding | jca/SignEncryptCombinations.java:92:44:92:62 | PaddingAlgorithm | +| jca/SignEncryptCombinations.java:96:42:96:44 | Key | Source | jca/SignEncryptCombinations.java:84:16:84:31 | Key | +| jca/SignEncryptCombinations.java:96:47:96:50 | Nonce | Source | jca/SignEncryptCombinations.java:94:9:94:28 | RandomNumberGeneration | +| jca/SignEncryptCombinations.java:96:47:96:50 | Nonce | Source | jca/SignEncryptCombinations.java:94:26:94:27 | RandomNumberGeneration | +| jca/SignEncryptCombinations.java:97:29:97:53 | EncryptOperation | Algorithm | jca/SignEncryptCombinations.java:92:44:92:62 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:97:29:97:53 | EncryptOperation | Input | jca/SignEncryptCombinations.java:97:44:97:52 | Message | +| jca/SignEncryptCombinations.java:97:29:97:53 | EncryptOperation | Key | jca/SignEncryptCombinations.java:96:42:96:44 | Key | +| jca/SignEncryptCombinations.java:97:29:97:53 | EncryptOperation | Nonce | jca/SignEncryptCombinations.java:96:47:96:50 | Nonce | +| jca/SignEncryptCombinations.java:97:29:97:53 | EncryptOperation | Output | jca/SignEncryptCombinations.java:97:29:97:53 | KeyOperationOutput | +| jca/SignEncryptCombinations.java:97:44:97:52 | Message | Source | jca/SignEncryptCombinations.java:64:16:64:31 | SignatureOutput | +| jca/SignEncryptCombinations.java:97:44:97:52 | Message | Source | jca/SignEncryptCombinations.java:335:26:335:47 | Constant | +| jca/SignEncryptCombinations.java:111:44:111:62 | KeyOperationAlgorithm | Mode | jca/SignEncryptCombinations.java:111:44:111:62 | ModeOfOperation | +| jca/SignEncryptCombinations.java:111:44:111:62 | KeyOperationAlgorithm | Padding | jca/SignEncryptCombinations.java:111:44:111:62 | PaddingAlgorithm | +| jca/SignEncryptCombinations.java:112:42:112:44 | Key | Source | jca/SignEncryptCombinations.java:84:16:84:31 | Key | +| jca/SignEncryptCombinations.java:112:47:112:75 | Nonce | Source | jca/SignEncryptCombinations.java:112:47:112:75 | Nonce | +| jca/SignEncryptCombinations.java:113:16:113:41 | DecryptOperation | Algorithm | jca/SignEncryptCombinations.java:111:44:111:62 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:113:16:113:41 | DecryptOperation | Input | jca/SignEncryptCombinations.java:113:31:113:40 | Message | +| jca/SignEncryptCombinations.java:113:16:113:41 | DecryptOperation | Key | jca/SignEncryptCombinations.java:112:42:112:44 | Key | +| jca/SignEncryptCombinations.java:113:16:113:41 | DecryptOperation | Nonce | jca/SignEncryptCombinations.java:112:47:112:75 | Nonce | +| jca/SignEncryptCombinations.java:113:16:113:41 | DecryptOperation | Output | jca/SignEncryptCombinations.java:113:16:113:41 | KeyOperationOutput | +| jca/SignEncryptCombinations.java:113:31:113:40 | Message | Source | jca/SignEncryptCombinations.java:113:31:113:40 | Message | +| jca/SignEncryptCombinations.java:121:35:121:46 | KeyOperationAlgorithm | Mode | jca/SignEncryptCombinations.java:121:35:121:46 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:121:35:121:46 | KeyOperationAlgorithm | Padding | jca/SignEncryptCombinations.java:121:35:121:46 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:122:18:122:20 | Key | Source | jca/SignEncryptCombinations.java:84:16:84:31 | Key | +| jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | Algorithm | jca/SignEncryptCombinations.java:121:35:121:46 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | HashAlgorithm | jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | +| jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | Input | jca/SignEncryptCombinations.java:123:28:123:31 | Message | +| jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | Key | jca/SignEncryptCombinations.java:122:18:122:20 | Key | +| jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | Message | jca/SignEncryptCombinations.java:123:28:123:31 | Message | +| jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | Nonce | jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | +| jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | Output | jca/SignEncryptCombinations.java:123:16:123:32 | KeyOperationOutput | +| jca/SignEncryptCombinations.java:123:28:123:31 | Message | Source | jca/SignEncryptCombinations.java:335:26:335:47 | Constant | +| jca/SignatureOperation.java:54:16:54:36 | Key | Algorithm | jca/SignatureOperation.java:52:61:52:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:54:16:54:36 | KeyGeneration | Algorithm | jca/SignatureOperation.java:52:61:52:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:54:16:54:36 | KeyGeneration | Output | jca/SignatureOperation.java:54:16:54:36 | Key | +| jca/SignatureOperation.java:63:53:63:74 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:63:53:63:74 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:63:53:63:74 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:63:53:63:74 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:64:28:64:37 | Key | Source | jca/SignatureOperation.java:54:16:54:36 | Key | +| jca/SignatureOperation.java:65:26:65:29 | Message | Source | jca/SignatureOperation.java:311:26:311:49 | Constant | +| jca/SignatureOperation.java:66:16:66:31 | SignOperation | Algorithm | jca/SignatureOperation.java:63:53:63:74 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:66:16:66:31 | SignOperation | HashAlgorithm | jca/SignatureOperation.java:63:53:63:74 | HashAlgorithm | +| jca/SignatureOperation.java:66:16:66:31 | SignOperation | Input | jca/SignatureOperation.java:65:26:65:29 | Message | +| jca/SignatureOperation.java:66:16:66:31 | SignOperation | Key | jca/SignatureOperation.java:64:28:64:37 | Key | +| jca/SignatureOperation.java:66:16:66:31 | SignOperation | Output | jca/SignatureOperation.java:66:16:66:31 | SignatureOutput | +| jca/SignatureOperation.java:75:53:75:74 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:75:53:75:74 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:75:53:75:74 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:75:53:75:74 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:76:30:76:38 | Key | Source | jca/SignatureOperation.java:54:16:54:36 | Key | +| jca/SignatureOperation.java:77:26:77:29 | Message | Source | jca/SignatureOperation.java:311:26:311:49 | Constant | +| jca/SignatureOperation.java:78:16:78:41 | VerifyOperation | Algorithm | jca/SignatureOperation.java:75:53:75:74 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:78:16:78:41 | VerifyOperation | HashAlgorithm | jca/SignatureOperation.java:75:53:75:74 | HashAlgorithm | +| jca/SignatureOperation.java:78:16:78:41 | VerifyOperation | Input | jca/SignatureOperation.java:77:26:77:29 | Message | +| jca/SignatureOperation.java:78:16:78:41 | VerifyOperation | Key | jca/SignatureOperation.java:76:30:76:38 | Key | +| jca/SignatureOperation.java:78:16:78:41 | VerifyOperation | Signature | jca/SignatureOperation.java:78:33:78:40 | SignatureInput | +| jca/SignatureOperation.java:78:33:78:40 | SignatureInput | Source | jca/SignatureOperation.java:66:16:66:31 | SignatureOutput | +| jca/SignatureOperation.java:94:16:94:38 | Key | Algorithm | jca/SignatureOperation.java:93:49:93:59 | EllipticCurve | +| jca/SignatureOperation.java:94:16:94:38 | KeyGeneration | Algorithm | jca/SignatureOperation.java:93:49:93:59 | EllipticCurve | +| jca/SignatureOperation.java:94:16:94:38 | KeyGeneration | Output | jca/SignatureOperation.java:94:16:94:38 | Key | +| jca/SignatureOperation.java:103:53:103:69 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:103:53:103:69 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:103:53:103:69 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:103:53:103:69 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:104:28:104:37 | Key | Source | jca/SignatureOperation.java:94:16:94:38 | Key | +| jca/SignatureOperation.java:105:26:105:29 | Message | Source | jca/SignatureOperation.java:231:26:231:44 | Constant | +| jca/SignatureOperation.java:105:26:105:29 | Message | Source | jca/SignatureOperation.java:311:26:311:49 | Constant | +| jca/SignatureOperation.java:106:16:106:31 | SignOperation | Algorithm | jca/SignatureOperation.java:103:53:103:69 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:106:16:106:31 | SignOperation | HashAlgorithm | jca/SignatureOperation.java:103:53:103:69 | HashAlgorithm | +| jca/SignatureOperation.java:106:16:106:31 | SignOperation | Input | jca/SignatureOperation.java:105:26:105:29 | Message | +| jca/SignatureOperation.java:106:16:106:31 | SignOperation | Key | jca/SignatureOperation.java:104:28:104:37 | Key | +| jca/SignatureOperation.java:106:16:106:31 | SignOperation | Output | jca/SignatureOperation.java:106:16:106:31 | SignatureOutput | +| jca/SignatureOperation.java:115:53:115:69 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:115:53:115:69 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:115:53:115:69 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:115:53:115:69 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:116:30:116:38 | Key | Source | jca/SignatureOperation.java:94:16:94:38 | Key | +| jca/SignatureOperation.java:117:26:117:29 | Message | Source | jca/SignatureOperation.java:231:26:231:44 | Constant | +| jca/SignatureOperation.java:117:26:117:29 | Message | Source | jca/SignatureOperation.java:311:26:311:49 | Constant | +| jca/SignatureOperation.java:118:16:118:41 | VerifyOperation | Algorithm | jca/SignatureOperation.java:115:53:115:69 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:118:16:118:41 | VerifyOperation | HashAlgorithm | jca/SignatureOperation.java:115:53:115:69 | HashAlgorithm | +| jca/SignatureOperation.java:118:16:118:41 | VerifyOperation | Input | jca/SignatureOperation.java:117:26:117:29 | Message | +| jca/SignatureOperation.java:118:16:118:41 | VerifyOperation | Key | jca/SignatureOperation.java:116:30:116:38 | Key | +| jca/SignatureOperation.java:118:16:118:41 | VerifyOperation | Signature | jca/SignatureOperation.java:118:33:118:40 | SignatureInput | +| jca/SignatureOperation.java:118:33:118:40 | SignatureInput | Source | jca/SignatureOperation.java:106:16:106:31 | SignatureOutput | +| jca/SignatureOperation.java:118:33:118:40 | SignatureInput | Source | jca/SignatureOperation.java:236:27:236:30 | Constant | +| jca/SignatureOperation.java:133:16:133:36 | Key | Algorithm | jca/SignatureOperation.java:132:61:132:69 | Constant | +| jca/SignatureOperation.java:133:16:133:36 | KeyGeneration | Algorithm | jca/SignatureOperation.java:132:61:132:69 | Constant | +| jca/SignatureOperation.java:133:16:133:36 | KeyGeneration | Output | jca/SignatureOperation.java:133:16:133:36 | Key | +| jca/SignatureOperation.java:142:53:142:61 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:142:53:142:61 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:142:53:142:61 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:142:53:142:61 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:143:28:143:37 | Key | Source | jca/SignatureOperation.java:133:16:133:36 | Key | +| jca/SignatureOperation.java:144:26:144:29 | Message | Source | jca/SignatureOperation.java:311:26:311:49 | Constant | +| jca/SignatureOperation.java:145:16:145:31 | SignOperation | Algorithm | jca/SignatureOperation.java:142:53:142:61 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:145:16:145:31 | SignOperation | HashAlgorithm | jca/SignatureOperation.java:145:16:145:31 | SignOperation | +| jca/SignatureOperation.java:145:16:145:31 | SignOperation | Input | jca/SignatureOperation.java:144:26:144:29 | Message | +| jca/SignatureOperation.java:145:16:145:31 | SignOperation | Key | jca/SignatureOperation.java:143:28:143:37 | Key | +| jca/SignatureOperation.java:145:16:145:31 | SignOperation | Output | jca/SignatureOperation.java:145:16:145:31 | SignatureOutput | +| jca/SignatureOperation.java:154:53:154:61 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:154:53:154:61 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:154:53:154:61 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:154:53:154:61 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:155:30:155:38 | Key | Source | jca/SignatureOperation.java:133:16:133:36 | Key | +| jca/SignatureOperation.java:156:26:156:29 | Message | Source | jca/SignatureOperation.java:311:26:311:49 | Constant | +| jca/SignatureOperation.java:157:16:157:41 | VerifyOperation | Algorithm | jca/SignatureOperation.java:154:53:154:61 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:157:16:157:41 | VerifyOperation | HashAlgorithm | jca/SignatureOperation.java:157:16:157:41 | VerifyOperation | +| jca/SignatureOperation.java:157:16:157:41 | VerifyOperation | Input | jca/SignatureOperation.java:156:26:156:29 | Message | +| jca/SignatureOperation.java:157:16:157:41 | VerifyOperation | Key | jca/SignatureOperation.java:155:30:155:38 | Key | +| jca/SignatureOperation.java:157:16:157:41 | VerifyOperation | Signature | jca/SignatureOperation.java:157:33:157:40 | SignatureInput | +| jca/SignatureOperation.java:157:33:157:40 | SignatureInput | Source | jca/SignatureOperation.java:145:16:145:31 | SignatureOutput | +| jca/SignatureOperation.java:175:16:175:36 | Key | Algorithm | jca/SignatureOperation.java:173:61:173:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:175:16:175:36 | KeyGeneration | Algorithm | jca/SignatureOperation.java:173:61:173:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:175:16:175:36 | KeyGeneration | Output | jca/SignatureOperation.java:175:16:175:36 | Key | +| jca/SignatureOperation.java:185:53:185:65 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:185:53:185:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:185:53:185:65 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:185:53:185:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:186:28:186:37 | Key | Source | jca/SignatureOperation.java:175:16:175:36 | Key | +| jca/SignatureOperation.java:187:26:187:29 | Message | Source | jca/SignatureOperation.java:311:26:311:49 | Constant | +| jca/SignatureOperation.java:188:16:188:31 | SignOperation | Algorithm | jca/SignatureOperation.java:185:53:185:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:188:16:188:31 | SignOperation | HashAlgorithm | jca/SignatureOperation.java:185:53:185:65 | HashAlgorithm | +| jca/SignatureOperation.java:188:16:188:31 | SignOperation | Input | jca/SignatureOperation.java:187:26:187:29 | Message | +| jca/SignatureOperation.java:188:16:188:31 | SignOperation | Key | jca/SignatureOperation.java:186:28:186:37 | Key | +| jca/SignatureOperation.java:188:16:188:31 | SignOperation | Output | jca/SignatureOperation.java:188:16:188:31 | SignatureOutput | +| jca/SignatureOperation.java:198:53:198:65 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:198:53:198:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:198:53:198:65 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:198:53:198:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:199:30:199:38 | Key | Source | jca/SignatureOperation.java:175:16:175:36 | Key | +| jca/SignatureOperation.java:200:26:200:29 | Message | Source | jca/SignatureOperation.java:311:26:311:49 | Constant | +| jca/SignatureOperation.java:201:16:201:41 | VerifyOperation | Algorithm | jca/SignatureOperation.java:198:53:198:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:201:16:201:41 | VerifyOperation | HashAlgorithm | jca/SignatureOperation.java:198:53:198:65 | HashAlgorithm | +| jca/SignatureOperation.java:201:16:201:41 | VerifyOperation | Input | jca/SignatureOperation.java:200:26:200:29 | Message | +| jca/SignatureOperation.java:201:16:201:41 | VerifyOperation | Key | jca/SignatureOperation.java:199:30:199:38 | Key | +| jca/SignatureOperation.java:201:16:201:41 | VerifyOperation | Signature | jca/SignatureOperation.java:201:33:201:40 | SignatureInput | +| jca/SignatureOperation.java:201:33:201:40 | SignatureInput | Source | jca/SignatureOperation.java:188:16:188:31 | SignatureOutput | +| jca/SignatureOperation.java:266:47:266:68 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:266:47:266:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:266:47:266:68 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:266:47:266:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:269:47:269:63 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:269:47:269:63 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:269:47:269:63 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:269:47:269:63 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:272:47:272:55 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:272:47:272:55 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:272:47:272:55 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:272:47:272:55 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:275:47:275:59 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:275:47:275:59 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:275:47:275:59 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:275:47:275:59 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:279:47:279:68 | KeyOperationAlgorithm | Mode | jca/SignatureOperation.java:279:47:279:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:279:47:279:68 | KeyOperationAlgorithm | Padding | jca/SignatureOperation.java:279:47:279:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:283:28:283:42 | Key | Source | jca/SignatureOperation.java:54:16:54:36 | Key | +| jca/SignatureOperation.java:283:28:283:42 | Key | Source | jca/SignatureOperation.java:94:16:94:38 | Key | +| jca/SignatureOperation.java:283:28:283:42 | Key | Source | jca/SignatureOperation.java:133:16:133:36 | Key | +| jca/SignatureOperation.java:283:28:283:42 | Key | Source | jca/SignatureOperation.java:175:16:175:36 | Key | +| jca/SignatureOperation.java:284:26:284:32 | Message | Source | jca/SignatureOperation.java:282:26:282:49 | Constant | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | Algorithm | jca/SignatureOperation.java:266:47:266:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | Algorithm | jca/SignatureOperation.java:269:47:269:63 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | Algorithm | jca/SignatureOperation.java:272:47:272:55 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | Algorithm | jca/SignatureOperation.java:275:47:275:59 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | Algorithm | jca/SignatureOperation.java:279:47:279:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | HashAlgorithm | jca/SignatureOperation.java:266:47:266:68 | HashAlgorithm | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | HashAlgorithm | jca/SignatureOperation.java:269:47:269:63 | HashAlgorithm | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | HashAlgorithm | jca/SignatureOperation.java:275:47:275:59 | HashAlgorithm | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | HashAlgorithm | jca/SignatureOperation.java:279:47:279:68 | HashAlgorithm | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | Input | jca/SignatureOperation.java:284:26:284:32 | Message | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | Key | jca/SignatureOperation.java:283:28:283:42 | Key | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | Output | jca/SignatureOperation.java:285:27:285:42 | SignatureOutput | +| jca/SignatureOperation.java:287:30:287:43 | Key | Source | jca/SignatureOperation.java:54:16:54:36 | Key | +| jca/SignatureOperation.java:287:30:287:43 | Key | Source | jca/SignatureOperation.java:94:16:94:38 | Key | +| jca/SignatureOperation.java:287:30:287:43 | Key | Source | jca/SignatureOperation.java:133:16:133:36 | Key | +| jca/SignatureOperation.java:287:30:287:43 | Key | Source | jca/SignatureOperation.java:175:16:175:36 | Key | +| jca/SignatureOperation.java:288:26:288:32 | Message | Source | jca/SignatureOperation.java:288:26:288:32 | Message | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Algorithm | jca/SignatureOperation.java:266:47:266:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Algorithm | jca/SignatureOperation.java:269:47:269:63 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Algorithm | jca/SignatureOperation.java:272:47:272:55 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Algorithm | jca/SignatureOperation.java:275:47:275:59 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Algorithm | jca/SignatureOperation.java:279:47:279:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | HashAlgorithm | jca/SignatureOperation.java:266:47:266:68 | HashAlgorithm | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | HashAlgorithm | jca/SignatureOperation.java:269:47:269:63 | HashAlgorithm | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | HashAlgorithm | jca/SignatureOperation.java:275:47:275:59 | HashAlgorithm | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | HashAlgorithm | jca/SignatureOperation.java:279:47:279:68 | HashAlgorithm | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Input | jca/SignatureOperation.java:284:26:284:32 | Message | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Input | jca/SignatureOperation.java:288:26:288:32 | Message | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Key | jca/SignatureOperation.java:283:28:283:42 | Key | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Key | jca/SignatureOperation.java:287:30:287:43 | Key | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | Signature | jca/SignatureOperation.java:289:45:289:52 | SignatureInput | +| jca/SignatureOperation.java:289:45:289:52 | SignatureInput | Source | jca/SignatureOperation.java:285:27:285:42 | SignatureOutput | +| jca/SymmetricAlgorithm.java:51:44:51:62 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:51:44:51:62 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:51:44:51:62 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:51:44:51:62 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:55:42:55:44 | Key | Source | jca/SymmetricAlgorithm.java:244:64:244:76 | Parameter | +| jca/SymmetricAlgorithm.java:55:47:55:50 | Nonce | Source | jca/SymmetricAlgorithm.java:53:9:53:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:55:47:55:50 | Nonce | Source | jca/SymmetricAlgorithm.java:53:38:53:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:56:29:56:53 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:51:44:51:62 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:56:29:56:53 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:56:44:56:52 | Message | +| jca/SymmetricAlgorithm.java:56:29:56:53 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:55:42:55:44 | Key | +| jca/SymmetricAlgorithm.java:56:29:56:53 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:55:47:55:50 | Nonce | +| jca/SymmetricAlgorithm.java:56:29:56:53 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:56:29:56:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:56:44:56:52 | Message | Source | jca/SymmetricAlgorithm.java:244:79:244:94 | Parameter | +| jca/SymmetricAlgorithm.java:73:44:73:62 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:73:44:73:62 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:73:44:73:62 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:73:44:73:62 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:76:42:76:44 | Key | Source | jca/SymmetricAlgorithm.java:72:39:72:51 | Parameter | +| jca/SymmetricAlgorithm.java:76:47:76:50 | Nonce | Source | jca/SymmetricAlgorithm.java:76:47:76:50 | Nonce | +| jca/SymmetricAlgorithm.java:77:29:77:53 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:73:44:73:62 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:77:29:77:53 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:77:44:77:52 | Message | +| jca/SymmetricAlgorithm.java:77:29:77:53 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:76:42:76:44 | Key | +| jca/SymmetricAlgorithm.java:77:29:77:53 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:76:47:76:50 | Nonce | +| jca/SymmetricAlgorithm.java:77:29:77:53 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:77:29:77:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:77:44:77:52 | Message | Source | jca/SymmetricAlgorithm.java:72:54:72:69 | Parameter | +| jca/SymmetricAlgorithm.java:94:44:94:65 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:94:44:94:65 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:94:44:94:65 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:94:44:94:65 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:98:42:98:44 | Key | Source | jca/SymmetricAlgorithm.java:244:64:244:76 | Parameter | +| jca/SymmetricAlgorithm.java:98:47:98:52 | Nonce | Source | jca/SymmetricAlgorithm.java:96:9:96:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:98:47:98:52 | Nonce | Source | jca/SymmetricAlgorithm.java:96:38:96:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:99:29:99:53 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:94:44:94:65 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:99:29:99:53 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:99:44:99:52 | Message | +| jca/SymmetricAlgorithm.java:99:29:99:53 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:98:42:98:44 | Key | +| jca/SymmetricAlgorithm.java:99:29:99:53 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:98:47:98:52 | Nonce | +| jca/SymmetricAlgorithm.java:99:29:99:53 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:99:29:99:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:99:44:99:52 | Message | Source | jca/SymmetricAlgorithm.java:244:79:244:94 | Parameter | +| jca/SymmetricAlgorithm.java:116:44:116:65 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:116:44:116:65 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:116:44:116:65 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:116:44:116:65 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:117:42:117:44 | Key | Source | jca/SymmetricAlgorithm.java:244:64:244:76 | Parameter | +| jca/SymmetricAlgorithm.java:118:16:118:40 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:116:44:116:65 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:118:16:118:40 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:118:31:118:39 | Message | +| jca/SymmetricAlgorithm.java:118:16:118:40 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:117:42:117:44 | Key | +| jca/SymmetricAlgorithm.java:118:16:118:40 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:118:16:118:40 | EncryptOperation | +| jca/SymmetricAlgorithm.java:118:16:118:40 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:118:16:118:40 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:118:31:118:39 | Message | Source | jca/SymmetricAlgorithm.java:244:79:244:94 | Parameter | +| jca/SymmetricAlgorithm.java:131:44:131:48 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:131:44:131:48 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:131:44:131:48 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:131:44:131:48 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:132:42:132:44 | Key | Source | jca/SymmetricAlgorithm.java:244:64:244:76 | Parameter | +| jca/SymmetricAlgorithm.java:133:16:133:40 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:131:44:131:48 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:133:16:133:40 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:133:31:133:39 | Message | +| jca/SymmetricAlgorithm.java:133:16:133:40 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:132:42:132:44 | Key | +| jca/SymmetricAlgorithm.java:133:16:133:40 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:133:16:133:40 | EncryptOperation | +| jca/SymmetricAlgorithm.java:133:16:133:40 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:133:16:133:40 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:133:31:133:39 | Message | Source | jca/SymmetricAlgorithm.java:244:79:244:94 | Parameter | +| jca/SymmetricAlgorithm.java:146:44:146:65 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:146:44:146:65 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:146:44:146:65 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:146:44:146:65 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:150:42:150:44 | Key | Source | jca/SymmetricAlgorithm.java:145:36:145:48 | Parameter | +| jca/SymmetricAlgorithm.java:150:47:150:52 | Nonce | Source | jca/SymmetricAlgorithm.java:148:9:148:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:150:47:150:52 | Nonce | Source | jca/SymmetricAlgorithm.java:148:38:148:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:151:29:151:53 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:146:44:146:65 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:151:29:151:53 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:151:44:151:52 | Message | +| jca/SymmetricAlgorithm.java:151:29:151:53 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:150:42:150:44 | Key | +| jca/SymmetricAlgorithm.java:151:29:151:53 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:150:47:150:52 | Nonce | +| jca/SymmetricAlgorithm.java:151:29:151:53 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:151:29:151:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:151:44:151:52 | Message | Source | jca/SymmetricAlgorithm.java:145:51:145:66 | Parameter | +| jca/SymmetricAlgorithm.java:168:44:168:68 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:168:44:168:68 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:168:44:168:68 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:168:44:168:68 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:172:42:172:44 | Key | Source | jca/SymmetricAlgorithm.java:167:42:167:54 | Parameter | +| jca/SymmetricAlgorithm.java:172:47:172:52 | Nonce | Source | jca/SymmetricAlgorithm.java:170:9:170:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:172:47:172:52 | Nonce | Source | jca/SymmetricAlgorithm.java:170:38:170:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:173:29:173:53 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:168:44:168:68 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:173:29:173:53 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:173:44:173:52 | Message | +| jca/SymmetricAlgorithm.java:173:29:173:53 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:172:42:172:44 | Key | +| jca/SymmetricAlgorithm.java:173:29:173:53 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:172:47:172:52 | Nonce | +| jca/SymmetricAlgorithm.java:173:29:173:53 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:173:29:173:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:173:44:173:52 | Message | Source | jca/SymmetricAlgorithm.java:167:57:167:72 | Parameter | +| jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:194:42:194:44 | Key | Source | jca/SymmetricAlgorithm.java:244:64:244:76 | Parameter | +| jca/SymmetricAlgorithm.java:194:47:194:72 | Nonce | Source | jca/SymmetricAlgorithm.java:192:9:192:43 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:194:47:194:72 | Nonce | Source | jca/SymmetricAlgorithm.java:192:38:192:42 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:195:29:195:53 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:195:29:195:53 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:195:44:195:52 | Message | +| jca/SymmetricAlgorithm.java:195:29:195:53 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:194:42:194:44 | Key | +| jca/SymmetricAlgorithm.java:195:29:195:53 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:194:47:194:72 | Nonce | +| jca/SymmetricAlgorithm.java:195:29:195:53 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:195:29:195:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:195:44:195:52 | Message | Source | jca/SymmetricAlgorithm.java:244:79:244:94 | Parameter | +| jca/SymmetricAlgorithm.java:214:19:214:21 | Key | Source | jca/SymmetricAlgorithm.java:212:35:212:47 | Parameter | +| jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | Algorithm | jca/SymmetricAlgorithm.java:213:36:213:44 | Constant | +| jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | HashAlgorithm | jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | +| jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | Input | jca/SymmetricAlgorithm.java:215:42:215:50 | Message | +| jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | Key | jca/SymmetricAlgorithm.java:214:19:214:21 | Key | +| jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | Message | jca/SymmetricAlgorithm.java:215:42:215:50 | Message | +| jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | Nonce | jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | +| jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | Output | jca/SymmetricAlgorithm.java:215:29:215:51 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:215:42:215:50 | Message | Source | jca/SymmetricAlgorithm.java:212:50:212:65 | Parameter | +| jca/SymmetricAlgorithm.java:218:44:218:62 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:218:44:218:62 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:218:44:218:62 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:218:44:218:62 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:222:42:222:51 | Key | Source | jca/SymmetricAlgorithm.java:222:42:222:51 | Key | +| jca/SymmetricAlgorithm.java:222:54:222:57 | Nonce | Source | jca/SymmetricAlgorithm.java:220:9:220:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:222:54:222:57 | Nonce | Source | jca/SymmetricAlgorithm.java:220:38:220:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:223:29:223:53 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:218:44:218:62 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:223:29:223:53 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:223:44:223:52 | Message | +| jca/SymmetricAlgorithm.java:223:29:223:53 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:222:42:222:51 | Key | +| jca/SymmetricAlgorithm.java:223:29:223:53 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:222:54:222:57 | Nonce | +| jca/SymmetricAlgorithm.java:223:29:223:53 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:223:29:223:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:223:44:223:52 | Message | Source | jca/SymmetricAlgorithm.java:223:44:223:52 | Message | +| jca/SymmetricAlgorithm.java:287:42:287:66 | Message | Source | jca/SymmetricAlgorithm.java:284:58:284:70 | Parameter | +| jca/SymmetricAlgorithm.java:287:69:287:72 | Salt | Source | jca/SymmetricAlgorithm.java:345:9:345:42 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:287:69:287:72 | Salt | Source | jca/SymmetricAlgorithm.java:345:38:345:41 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:288:65:288:86 | HMACAlgorithm | H | jca/SymmetricAlgorithm.java:288:65:288:86 | HashAlgorithm | +| jca/SymmetricAlgorithm.java:288:65:288:86 | KeyDerivationAlgorithm | PRF | jca/SymmetricAlgorithm.java:288:65:288:86 | HMACAlgorithm | +| jca/SymmetricAlgorithm.java:289:26:289:53 | KeyDerivation | Algorithm | jca/SymmetricAlgorithm.java:288:65:288:86 | KeyDerivationAlgorithm | +| jca/SymmetricAlgorithm.java:289:26:289:53 | KeyDerivation | Input | jca/SymmetricAlgorithm.java:287:42:287:66 | Message | +| jca/SymmetricAlgorithm.java:289:26:289:53 | KeyDerivation | Output | jca/SymmetricAlgorithm.java:289:26:289:53 | Key | +| jca/SymmetricAlgorithm.java:289:26:289:53 | KeyDerivation | Salt | jca/SymmetricAlgorithm.java:287:69:287:72 | Salt | +| jca/SymmetricAlgorithm.java:295:44:295:62 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:295:44:295:62 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:295:44:295:62 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:295:44:295:62 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:298:42:298:47 | Key | Source | jca/SymmetricAlgorithm.java:298:42:298:47 | Key | +| jca/SymmetricAlgorithm.java:298:50:298:78 | Nonce | Source | jca/SymmetricAlgorithm.java:297:9:297:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:298:50:298:78 | Nonce | Source | jca/SymmetricAlgorithm.java:297:38:297:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:299:29:299:53 | EncryptOperation | Algorithm | jca/SymmetricAlgorithm.java:295:44:295:62 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:299:29:299:53 | EncryptOperation | Input | jca/SymmetricAlgorithm.java:299:44:299:52 | Message | +| jca/SymmetricAlgorithm.java:299:29:299:53 | EncryptOperation | Key | jca/SymmetricAlgorithm.java:298:42:298:47 | Key | +| jca/SymmetricAlgorithm.java:299:29:299:53 | EncryptOperation | Nonce | jca/SymmetricAlgorithm.java:298:50:298:78 | Nonce | +| jca/SymmetricAlgorithm.java:299:29:299:53 | EncryptOperation | Output | jca/SymmetricAlgorithm.java:299:29:299:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:299:44:299:52 | Message | Source | jca/SymmetricAlgorithm.java:284:73:284:88 | Parameter | +| jca/SymmetricAlgorithm.java:301:35:301:46 | KeyOperationAlgorithm | Mode | jca/SymmetricAlgorithm.java:301:35:301:46 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:301:35:301:46 | KeyOperationAlgorithm | Padding | jca/SymmetricAlgorithm.java:301:35:301:46 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:302:18:302:30 | Key | Source | jca/SymmetricAlgorithm.java:302:18:302:30 | Key | +| jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | Algorithm | jca/SymmetricAlgorithm.java:301:35:301:46 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | HashAlgorithm | jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | +| jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | Input | jca/SymmetricAlgorithm.java:303:42:303:51 | Message | +| jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | Key | jca/SymmetricAlgorithm.java:302:18:302:30 | Key | +| jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | Message | jca/SymmetricAlgorithm.java:303:42:303:51 | Message | +| jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | Nonce | jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | +| jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | Output | jca/SymmetricAlgorithm.java:303:30:303:52 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:303:42:303:51 | Message | Source | jca/SymmetricAlgorithm.java:299:29:299:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:333:16:333:31 | KeyGeneration | Algorithm | jca/SymmetricAlgorithm.java:331:52:331:56 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:333:16:333:31 | KeyGeneration | Output | jca/SymmetricAlgorithm.java:333:16:333:31 | Key | +| jca/SymmetricModesTest.java:50:33:50:48 | KeyGeneration | Algorithm | jca/SymmetricModesTest.java:48:52:48:56 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:50:33:50:48 | KeyGeneration | Output | jca/SymmetricModesTest.java:50:33:50:48 | Key | +| jca/SymmetricModesTest.java:54:31:54:46 | KeyGeneration | Algorithm | jca/SymmetricModesTest.java:48:52:48:56 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:54:31:54:46 | KeyGeneration | Output | jca/SymmetricModesTest.java:54:31:54:46 | Key | +| jca/SymmetricModesTest.java:57:44:57:62 | KeyOperationAlgorithm | Mode | jca/SymmetricModesTest.java:57:44:57:62 | ModeOfOperation | +| jca/SymmetricModesTest.java:57:44:57:62 | KeyOperationAlgorithm | Padding | jca/SymmetricModesTest.java:57:44:57:62 | PaddingAlgorithm | +| jca/SymmetricModesTest.java:58:39:58:49 | Key | Source | jca/SymmetricModesTest.java:50:33:50:48 | Key | +| jca/SymmetricModesTest.java:59:29:59:50 | WrapOperation | Algorithm | jca/SymmetricModesTest.java:57:44:57:62 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:59:29:59:50 | WrapOperation | Input | jca/SymmetricModesTest.java:59:41:59:49 | Message | +| jca/SymmetricModesTest.java:59:29:59:50 | WrapOperation | Key | jca/SymmetricModesTest.java:58:39:58:49 | Key | +| jca/SymmetricModesTest.java:59:29:59:50 | WrapOperation | Nonce | jca/SymmetricModesTest.java:59:29:59:50 | WrapOperation | +| jca/SymmetricModesTest.java:59:29:59:50 | WrapOperation | Output | jca/SymmetricModesTest.java:59:29:59:50 | KeyOperationOutput | +| jca/SymmetricModesTest.java:59:41:59:49 | Message | Source | jca/SymmetricModesTest.java:54:31:54:46 | Key | +| jca/SymmetricModesTest.java:79:44:79:63 | KeyOperationAlgorithm | Mode | jca/SymmetricModesTest.java:79:44:79:63 | ModeOfOperation | +| jca/SymmetricModesTest.java:79:44:79:63 | KeyOperationAlgorithm | Padding | jca/SymmetricModesTest.java:79:44:79:63 | PaddingAlgorithm | +| jca/SymmetricModesTest.java:83:42:83:44 | Key | Source | jca/SymmetricModesTest.java:78:43:78:55 | Parameter | +| jca/SymmetricModesTest.java:83:47:83:52 | Nonce | Source | jca/SymmetricModesTest.java:81:9:81:40 | RandomNumberGeneration | +| jca/SymmetricModesTest.java:83:47:83:52 | Nonce | Source | jca/SymmetricModesTest.java:81:38:81:39 | RandomNumberGeneration | +| jca/SymmetricModesTest.java:84:29:84:53 | EncryptOperation | Algorithm | jca/SymmetricModesTest.java:79:44:79:63 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:84:29:84:53 | EncryptOperation | Input | jca/SymmetricModesTest.java:84:44:84:52 | Message | +| jca/SymmetricModesTest.java:84:29:84:53 | EncryptOperation | Key | jca/SymmetricModesTest.java:83:42:83:44 | Key | +| jca/SymmetricModesTest.java:84:29:84:53 | EncryptOperation | Nonce | jca/SymmetricModesTest.java:83:47:83:52 | Nonce | +| jca/SymmetricModesTest.java:84:29:84:53 | EncryptOperation | Output | jca/SymmetricModesTest.java:84:29:84:53 | KeyOperationOutput | +| jca/SymmetricModesTest.java:84:44:84:52 | Message | Source | jca/SymmetricModesTest.java:78:58:78:73 | Parameter | +| jca/SymmetricModesTest.java:105:44:105:63 | KeyOperationAlgorithm | Mode | jca/SymmetricModesTest.java:105:44:105:63 | ModeOfOperation | +| jca/SymmetricModesTest.java:105:44:105:63 | KeyOperationAlgorithm | Padding | jca/SymmetricModesTest.java:105:44:105:63 | PaddingAlgorithm | +| jca/SymmetricModesTest.java:109:42:109:44 | Key | Source | jca/SymmetricModesTest.java:104:45:104:57 | Parameter | +| jca/SymmetricModesTest.java:109:47:109:52 | Nonce | Source | jca/SymmetricModesTest.java:109:47:109:52 | Nonce | +| jca/SymmetricModesTest.java:110:29:110:53 | EncryptOperation | Algorithm | jca/SymmetricModesTest.java:105:44:105:63 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:110:29:110:53 | EncryptOperation | Input | jca/SymmetricModesTest.java:110:44:110:52 | Message | +| jca/SymmetricModesTest.java:110:29:110:53 | EncryptOperation | Key | jca/SymmetricModesTest.java:109:42:109:44 | Key | +| jca/SymmetricModesTest.java:110:29:110:53 | EncryptOperation | Nonce | jca/SymmetricModesTest.java:109:47:109:52 | Nonce | +| jca/SymmetricModesTest.java:110:29:110:53 | EncryptOperation | Output | jca/SymmetricModesTest.java:110:29:110:53 | KeyOperationOutput | +| jca/SymmetricModesTest.java:110:44:110:52 | Message | Source | jca/SymmetricModesTest.java:104:60:104:75 | Parameter | +| jca/SymmetricModesTest.java:129:16:129:31 | KeyGeneration | Algorithm | jca/SymmetricModesTest.java:127:52:127:56 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:129:16:129:31 | KeyGeneration | Output | jca/SymmetricModesTest.java:129:16:129:31 | Key | +| jca/UniversalFlowTest.java:27:25:27:44 | KeyGeneration | Algorithm | jca/UniversalFlowTest.java:19:28:19:32 | KeyOperationAlgorithm | +| jca/UniversalFlowTest.java:27:25:27:44 | KeyGeneration | Algorithm | jca/UniversalFlowTest.java:46:20:46:24 | KeyOperationAlgorithm | +| jca/UniversalFlowTest.java:27:25:27:44 | KeyGeneration | Output | jca/UniversalFlowTest.java:27:25:27:44 | Key | +| jca/UniversalFlowTest.java:28:29:28:47 | KeyOperationAlgorithm | Mode | jca/UniversalFlowTest.java:28:29:28:47 | ModeOfOperation | +| jca/UniversalFlowTest.java:28:29:28:47 | KeyOperationAlgorithm | Padding | jca/UniversalFlowTest.java:28:29:28:47 | PaddingAlgorithm | +| jca/UniversalFlowTest.java:33:42:33:44 | Key | Source | jca/UniversalFlowTest.java:27:25:27:44 | Key | +| jca/UniversalFlowTest.java:33:47:33:53 | Nonce | Source | jca/UniversalFlowTest.java:31:9:31:40 | RandomNumberGeneration | +| jca/UniversalFlowTest.java:33:47:33:53 | Nonce | Source | jca/UniversalFlowTest.java:31:38:31:39 | RandomNumberGeneration | +| jca/UniversalFlowTest.java:34:32:34:74 | EncryptOperation | Algorithm | jca/UniversalFlowTest.java:28:29:28:47 | KeyOperationAlgorithm | +| jca/UniversalFlowTest.java:34:32:34:74 | EncryptOperation | Input | jca/UniversalFlowTest.java:34:47:34:73 | Message | +| jca/UniversalFlowTest.java:34:32:34:74 | EncryptOperation | Key | jca/UniversalFlowTest.java:33:42:33:44 | Key | +| jca/UniversalFlowTest.java:34:32:34:74 | EncryptOperation | Nonce | jca/UniversalFlowTest.java:33:47:33:53 | Nonce | +| jca/UniversalFlowTest.java:34:32:34:74 | EncryptOperation | Output | jca/UniversalFlowTest.java:34:32:34:74 | KeyOperationOutput | +| jca/UniversalFlowTest.java:34:47:34:73 | Message | Source | jca/UniversalFlowTest.java:34:47:34:62 | Constant | diff --git a/java/ql/test/experimental/library-tests/quantum/node_edges.ql b/java/ql/test/experimental/library-tests/quantum/node_edges.ql new file mode 100644 index 000000000000..4c9afb6c8ff5 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/node_edges.ql @@ -0,0 +1,5 @@ +import java +import experimental.quantum.Language + +from Crypto::NodeBase n, string key +select n, key, n.getChild(key) diff --git a/java/ql/test/experimental/library-tests/quantum/node_properties.expected b/java/ql/test/experimental/library-tests/quantum/node_properties.expected new file mode 100644 index 000000000000..ea071871fd94 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/node_properties.expected @@ -0,0 +1,1704 @@ +| jca/AesWrapAndPBEWith.java:58:52:58:56 | KeyOperationAlgorithm | KeySize | Constant:128 | jca/AesWrapAndPBEWith.java:62:17:62:19 | jca/AesWrapAndPBEWith.java:62:17:62:19 | +| jca/AesWrapAndPBEWith.java:58:52:58:56 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/AesWrapAndPBEWith.java:59:17:59:19 | jca/AesWrapAndPBEWith.java:59:17:59:19 | +| jca/AesWrapAndPBEWith.java:58:52:58:56 | KeyOperationAlgorithm | Name | AES | jca/AesWrapAndPBEWith.java:58:52:58:56 | jca/AesWrapAndPBEWith.java:58:52:58:56 | +| jca/AesWrapAndPBEWith.java:58:52:58:56 | KeyOperationAlgorithm | RawName | AES | jca/AesWrapAndPBEWith.java:58:52:58:56 | jca/AesWrapAndPBEWith.java:58:52:58:56 | +| jca/AesWrapAndPBEWith.java:58:52:58:56 | KeyOperationAlgorithm | Structure | Block | jca/AesWrapAndPBEWith.java:58:52:58:56 | jca/AesWrapAndPBEWith.java:58:52:58:56 | +| jca/AesWrapAndPBEWith.java:59:17:59:19 | Constant | Description | 256 | jca/AesWrapAndPBEWith.java:59:17:59:19 | jca/AesWrapAndPBEWith.java:59:17:59:19 | +| jca/AesWrapAndPBEWith.java:60:33:60:48 | Key | KeyType | Symmetric | jca/AesWrapAndPBEWith.java:60:33:60:48 | jca/AesWrapAndPBEWith.java:60:33:60:48 | +| jca/AesWrapAndPBEWith.java:62:17:62:19 | Constant | Description | 128 | jca/AesWrapAndPBEWith.java:62:17:62:19 | jca/AesWrapAndPBEWith.java:62:17:62:19 | +| jca/AesWrapAndPBEWith.java:63:31:63:46 | Key | KeyType | Symmetric | jca/AesWrapAndPBEWith.java:63:31:63:46 | jca/AesWrapAndPBEWith.java:63:31:63:46 | +| jca/AesWrapAndPBEWith.java:65:44:65:52 | KeyOperationAlgorithm | Name | AES | jca/AesWrapAndPBEWith.java:65:44:65:52 | jca/AesWrapAndPBEWith.java:65:44:65:52 | +| jca/AesWrapAndPBEWith.java:65:44:65:52 | KeyOperationAlgorithm | RawName | AESWrap | jca/AesWrapAndPBEWith.java:65:44:65:52 | jca/AesWrapAndPBEWith.java:65:44:65:52 | +| jca/AesWrapAndPBEWith.java:65:44:65:52 | KeyOperationAlgorithm | Structure | Block | jca/AesWrapAndPBEWith.java:65:44:65:52 | jca/AesWrapAndPBEWith.java:65:44:65:52 | +| jca/AesWrapAndPBEWith.java:66:39:66:49 | Key | KeyType | Unknown | jca/AesWrapAndPBEWith.java:66:39:66:49 | jca/AesWrapAndPBEWith.java:66:39:66:49 | +| jca/AesWrapAndPBEWith.java:67:29:67:50 | WrapOperation | KeyOperationSubtype | Wrap | jca/AesWrapAndPBEWith.java:67:29:67:50 | jca/AesWrapAndPBEWith.java:67:29:67:50 | +| jca/AesWrapAndPBEWith.java:83:52:83:56 | KeyOperationAlgorithm | KeySize | Constant:128 | jca/AesWrapAndPBEWith.java:84:17:84:19 | jca/AesWrapAndPBEWith.java:84:17:84:19 | +| jca/AesWrapAndPBEWith.java:83:52:83:56 | KeyOperationAlgorithm | Name | AES | jca/AesWrapAndPBEWith.java:83:52:83:56 | jca/AesWrapAndPBEWith.java:83:52:83:56 | +| jca/AesWrapAndPBEWith.java:83:52:83:56 | KeyOperationAlgorithm | RawName | AES | jca/AesWrapAndPBEWith.java:83:52:83:56 | jca/AesWrapAndPBEWith.java:83:52:83:56 | +| jca/AesWrapAndPBEWith.java:83:52:83:56 | KeyOperationAlgorithm | Structure | Block | jca/AesWrapAndPBEWith.java:83:52:83:56 | jca/AesWrapAndPBEWith.java:83:52:83:56 | +| jca/AesWrapAndPBEWith.java:84:17:84:19 | Constant | Description | 128 | jca/AesWrapAndPBEWith.java:84:17:84:19 | jca/AesWrapAndPBEWith.java:84:17:84:19 | +| jca/AesWrapAndPBEWith.java:85:31:85:46 | Key | KeyType | Symmetric | jca/AesWrapAndPBEWith.java:85:31:85:46 | jca/AesWrapAndPBEWith.java:85:31:85:46 | +| jca/AesWrapAndPBEWith.java:87:44:87:52 | KeyOperationAlgorithm | Name | AES | jca/AesWrapAndPBEWith.java:87:44:87:52 | jca/AesWrapAndPBEWith.java:87:44:87:52 | +| jca/AesWrapAndPBEWith.java:87:44:87:52 | KeyOperationAlgorithm | RawName | AESWrap | jca/AesWrapAndPBEWith.java:87:44:87:52 | jca/AesWrapAndPBEWith.java:87:44:87:52 | +| jca/AesWrapAndPBEWith.java:87:44:87:52 | KeyOperationAlgorithm | Structure | Block | jca/AesWrapAndPBEWith.java:87:44:87:52 | jca/AesWrapAndPBEWith.java:87:44:87:52 | +| jca/AesWrapAndPBEWith.java:88:39:88:49 | Key | KeyType | Unknown | jca/AesWrapAndPBEWith.java:88:39:88:49 | jca/AesWrapAndPBEWith.java:88:39:88:49 | +| jca/AesWrapAndPBEWith.java:89:29:89:50 | WrapOperation | KeyOperationSubtype | Wrap | jca/AesWrapAndPBEWith.java:89:29:89:50 | jca/AesWrapAndPBEWith.java:89:29:89:50 | +| jca/AesWrapAndPBEWith.java:106:34:106:37 | Constant | Description | 0x00 | jca/AesWrapAndPBEWith.java:106:34:106:37 | jca/AesWrapAndPBEWith.java:106:34:106:37 | +| jca/AesWrapAndPBEWith.java:107:72:107:75 | Constant | Description | 1000 | jca/AesWrapAndPBEWith.java:107:72:107:75 | jca/AesWrapAndPBEWith.java:107:72:107:75 | +| jca/AesWrapAndPBEWith.java:107:78:107:79 | Constant | Description | 64 | jca/AesWrapAndPBEWith.java:107:78:107:79 | jca/AesWrapAndPBEWith.java:107:78:107:79 | +| jca/AesWrapAndPBEWith.java:108:65:108:82 | KeyDerivationAlgorithm | Name | PBEWithMD5AndDES | jca/AesWrapAndPBEWith.java:108:65:108:82 | jca/AesWrapAndPBEWith.java:108:65:108:82 | +| jca/AesWrapAndPBEWith.java:108:65:108:82 | KeyDerivationAlgorithm | RawName | PBEWithMD5AndDES | jca/AesWrapAndPBEWith.java:108:65:108:82 | jca/AesWrapAndPBEWith.java:108:65:108:82 | +| jca/AesWrapAndPBEWith.java:109:27:109:54 | Key | KeyType | Symmetric | jca/AesWrapAndPBEWith.java:109:27:109:54 | jca/AesWrapAndPBEWith.java:109:27:109:54 | +| jca/AesWrapAndPBEWith.java:109:27:109:54 | KeyDerivation | Iterations | Constant:1000 | jca/AesWrapAndPBEWith.java:107:72:107:75 | jca/AesWrapAndPBEWith.java:107:72:107:75 | +| jca/AesWrapAndPBEWith.java:109:27:109:54 | KeyDerivation | KeySize | Constant:64 | jca/AesWrapAndPBEWith.java:107:78:107:79 | jca/AesWrapAndPBEWith.java:107:78:107:79 | +| jca/AesWrapAndPBEWith.java:122:9:122:42 | RandomNumberGeneration | Description | nextBytes | jca/AesWrapAndPBEWith.java:122:9:122:42 | jca/AesWrapAndPBEWith.java:122:9:122:42 | +| jca/AesWrapAndPBEWith.java:122:38:122:41 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/AesWrapAndPBEWith.java:122:38:122:41 | jca/AesWrapAndPBEWith.java:122:38:122:41 | +| jca/AesWrapAndPBEWith.java:123:72:123:76 | Constant | Description | 10000 | jca/AesWrapAndPBEWith.java:123:72:123:76 | jca/AesWrapAndPBEWith.java:123:72:123:76 | +| jca/AesWrapAndPBEWith.java:123:79:123:81 | Constant | Description | 256 | jca/AesWrapAndPBEWith.java:123:79:123:81 | jca/AesWrapAndPBEWith.java:123:79:123:81 | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | HMACAlgorithm | Name | HMAC | jca/AesWrapAndPBEWith.java:124:65:124:86 | jca/AesWrapAndPBEWith.java:124:65:124:86 | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/AesWrapAndPBEWith.java:124:65:124:86 | jca/AesWrapAndPBEWith.java:124:65:124:86 | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | HashAlgorithm | DigestSize | 256 | jca/AesWrapAndPBEWith.java:124:65:124:86 | jca/AesWrapAndPBEWith.java:124:65:124:86 | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | HashAlgorithm | Name | SHA2 | jca/AesWrapAndPBEWith.java:124:65:124:86 | jca/AesWrapAndPBEWith.java:124:65:124:86 | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/AesWrapAndPBEWith.java:124:65:124:86 | jca/AesWrapAndPBEWith.java:124:65:124:86 | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/AesWrapAndPBEWith.java:124:65:124:86 | jca/AesWrapAndPBEWith.java:124:65:124:86 | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/AesWrapAndPBEWith.java:124:65:124:86 | jca/AesWrapAndPBEWith.java:124:65:124:86 | +| jca/AesWrapAndPBEWith.java:125:27:125:54 | Key | KeyType | Symmetric | jca/AesWrapAndPBEWith.java:125:27:125:54 | jca/AesWrapAndPBEWith.java:125:27:125:54 | +| jca/AesWrapAndPBEWith.java:125:27:125:54 | KeyDerivation | Iterations | Constant:10000 | jca/AesWrapAndPBEWith.java:123:72:123:76 | jca/AesWrapAndPBEWith.java:123:72:123:76 | +| jca/AesWrapAndPBEWith.java:125:27:125:54 | KeyDerivation | KeySize | Constant:256 | jca/AesWrapAndPBEWith.java:123:79:123:81 | jca/AesWrapAndPBEWith.java:123:79:123:81 | +| jca/AesWrapAndPBEWith.java:140:9:140:42 | RandomNumberGeneration | Description | nextBytes | jca/AesWrapAndPBEWith.java:140:9:140:42 | jca/AesWrapAndPBEWith.java:140:9:140:42 | +| jca/AesWrapAndPBEWith.java:140:38:140:41 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/AesWrapAndPBEWith.java:140:38:140:41 | jca/AesWrapAndPBEWith.java:140:38:140:41 | +| jca/AesWrapAndPBEWith.java:141:72:141:76 | Constant | Description | 10000 | jca/AesWrapAndPBEWith.java:141:72:141:76 | jca/AesWrapAndPBEWith.java:141:72:141:76 | +| jca/AesWrapAndPBEWith.java:141:79:141:81 | Constant | Description | 128 | jca/AesWrapAndPBEWith.java:141:79:141:81 | jca/AesWrapAndPBEWith.java:141:79:141:81 | +| jca/AesWrapAndPBEWith.java:142:65:142:98 | KeyDerivationAlgorithm | Name | PBEWithSHA256And128BitAES-CBC-BC | jca/AesWrapAndPBEWith.java:142:65:142:98 | jca/AesWrapAndPBEWith.java:142:65:142:98 | +| jca/AesWrapAndPBEWith.java:142:65:142:98 | KeyDerivationAlgorithm | RawName | PBEWithSHA256And128BitAES-CBC-BC | jca/AesWrapAndPBEWith.java:142:65:142:98 | jca/AesWrapAndPBEWith.java:142:65:142:98 | +| jca/AesWrapAndPBEWith.java:143:28:143:55 | Key | KeyType | Symmetric | jca/AesWrapAndPBEWith.java:143:28:143:55 | jca/AesWrapAndPBEWith.java:143:28:143:55 | +| jca/AesWrapAndPBEWith.java:143:28:143:55 | KeyDerivation | Iterations | Constant:10000 | jca/AesWrapAndPBEWith.java:141:72:141:76 | jca/AesWrapAndPBEWith.java:141:72:141:76 | +| jca/AesWrapAndPBEWith.java:143:28:143:55 | KeyDerivation | KeySize | Constant:128 | jca/AesWrapAndPBEWith.java:141:79:141:81 | jca/AesWrapAndPBEWith.java:141:79:141:81 | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | KeyOperationAlgorithm | Name | AES | jca/AesWrapAndPBEWith.java:146:44:146:65 | jca/AesWrapAndPBEWith.java:146:44:146:65 | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | KeyOperationAlgorithm | RawName | AES/CBC/PKCS5Padding | jca/AesWrapAndPBEWith.java:146:44:146:65 | jca/AesWrapAndPBEWith.java:146:44:146:65 | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | KeyOperationAlgorithm | Structure | Block | jca/AesWrapAndPBEWith.java:146:44:146:65 | jca/AesWrapAndPBEWith.java:146:44:146:65 | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | ModeOfOperation | Name | CBC | jca/AesWrapAndPBEWith.java:146:44:146:65 | jca/AesWrapAndPBEWith.java:146:44:146:65 | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | ModeOfOperation | RawName | CBC | jca/AesWrapAndPBEWith.java:146:44:146:65 | jca/AesWrapAndPBEWith.java:146:44:146:65 | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | PaddingAlgorithm | Name | PKCS7 | jca/AesWrapAndPBEWith.java:146:44:146:65 | jca/AesWrapAndPBEWith.java:146:44:146:65 | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | PaddingAlgorithm | RawName | PKCS5Padding | jca/AesWrapAndPBEWith.java:146:44:146:65 | jca/AesWrapAndPBEWith.java:146:44:146:65 | +| jca/AesWrapAndPBEWith.java:148:9:148:40 | RandomNumberGeneration | Description | nextBytes | jca/AesWrapAndPBEWith.java:148:9:148:40 | jca/AesWrapAndPBEWith.java:148:9:148:40 | +| jca/AesWrapAndPBEWith.java:148:38:148:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/AesWrapAndPBEWith.java:148:38:148:39 | jca/AesWrapAndPBEWith.java:148:38:148:39 | +| jca/AesWrapAndPBEWith.java:150:42:150:47 | Key | KeyType | Unknown | jca/AesWrapAndPBEWith.java:150:42:150:47 | jca/AesWrapAndPBEWith.java:150:42:150:47 | +| jca/AesWrapAndPBEWith.java:151:29:151:64 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/AesWrapAndPBEWith.java:151:29:151:64 | jca/AesWrapAndPBEWith.java:151:29:151:64 | +| jca/AesWrapAndPBEWith.java:167:9:167:42 | RandomNumberGeneration | Description | nextBytes | jca/AesWrapAndPBEWith.java:167:9:167:42 | jca/AesWrapAndPBEWith.java:167:9:167:42 | +| jca/AesWrapAndPBEWith.java:167:38:167:41 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/AesWrapAndPBEWith.java:167:38:167:41 | jca/AesWrapAndPBEWith.java:167:38:167:41 | +| jca/AesWrapAndPBEWith.java:168:72:168:76 | Constant | Description | 10000 | jca/AesWrapAndPBEWith.java:168:72:168:76 | jca/AesWrapAndPBEWith.java:168:72:168:76 | +| jca/AesWrapAndPBEWith.java:168:79:168:81 | Constant | Description | 128 | jca/AesWrapAndPBEWith.java:168:79:168:81 | jca/AesWrapAndPBEWith.java:168:79:168:81 | +| jca/AesWrapAndPBEWith.java:169:65:169:96 | KeyDerivationAlgorithm | Name | PBEWithSHA1And128BitAES-CBC-BC | jca/AesWrapAndPBEWith.java:169:65:169:96 | jca/AesWrapAndPBEWith.java:169:65:169:96 | +| jca/AesWrapAndPBEWith.java:169:65:169:96 | KeyDerivationAlgorithm | RawName | PBEWithSHA1And128BitAES-CBC-BC | jca/AesWrapAndPBEWith.java:169:65:169:96 | jca/AesWrapAndPBEWith.java:169:65:169:96 | +| jca/AesWrapAndPBEWith.java:170:28:170:55 | Key | KeyType | Symmetric | jca/AesWrapAndPBEWith.java:170:28:170:55 | jca/AesWrapAndPBEWith.java:170:28:170:55 | +| jca/AesWrapAndPBEWith.java:170:28:170:55 | KeyDerivation | Iterations | Constant:10000 | jca/AesWrapAndPBEWith.java:168:72:168:76 | jca/AesWrapAndPBEWith.java:168:72:168:76 | +| jca/AesWrapAndPBEWith.java:170:28:170:55 | KeyDerivation | KeySize | Constant:128 | jca/AesWrapAndPBEWith.java:168:79:168:81 | jca/AesWrapAndPBEWith.java:168:79:168:81 | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | KeyOperationAlgorithm | Name | AES | jca/AesWrapAndPBEWith.java:173:44:173:65 | jca/AesWrapAndPBEWith.java:173:44:173:65 | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | KeyOperationAlgorithm | RawName | AES/CBC/PKCS5Padding | jca/AesWrapAndPBEWith.java:173:44:173:65 | jca/AesWrapAndPBEWith.java:173:44:173:65 | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | KeyOperationAlgorithm | Structure | Block | jca/AesWrapAndPBEWith.java:173:44:173:65 | jca/AesWrapAndPBEWith.java:173:44:173:65 | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | ModeOfOperation | Name | CBC | jca/AesWrapAndPBEWith.java:173:44:173:65 | jca/AesWrapAndPBEWith.java:173:44:173:65 | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | ModeOfOperation | RawName | CBC | jca/AesWrapAndPBEWith.java:173:44:173:65 | jca/AesWrapAndPBEWith.java:173:44:173:65 | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | PaddingAlgorithm | Name | PKCS7 | jca/AesWrapAndPBEWith.java:173:44:173:65 | jca/AesWrapAndPBEWith.java:173:44:173:65 | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | PaddingAlgorithm | RawName | PKCS5Padding | jca/AesWrapAndPBEWith.java:173:44:173:65 | jca/AesWrapAndPBEWith.java:173:44:173:65 | +| jca/AesWrapAndPBEWith.java:175:9:175:40 | RandomNumberGeneration | Description | nextBytes | jca/AesWrapAndPBEWith.java:175:9:175:40 | jca/AesWrapAndPBEWith.java:175:9:175:40 | +| jca/AesWrapAndPBEWith.java:175:38:175:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/AesWrapAndPBEWith.java:175:38:175:39 | jca/AesWrapAndPBEWith.java:175:38:175:39 | +| jca/AesWrapAndPBEWith.java:177:42:177:47 | Key | KeyType | Unknown | jca/AesWrapAndPBEWith.java:177:42:177:47 | jca/AesWrapAndPBEWith.java:177:42:177:47 | +| jca/AesWrapAndPBEWith.java:178:29:178:64 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/AesWrapAndPBEWith.java:178:29:178:64 | jca/AesWrapAndPBEWith.java:178:29:178:64 | +| jca/AesWrapAndPBEWith.java:200:55:200:69 | Parameter | Description | password | jca/AesWrapAndPBEWith.java:200:55:200:69 | jca/AesWrapAndPBEWith.java:200:55:200:69 | +| jca/AesWrapAndPBEWith.java:200:72:200:87 | Parameter | Description | plaintext | jca/AesWrapAndPBEWith.java:200:72:200:87 | jca/AesWrapAndPBEWith.java:200:72:200:87 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | EllipticCurve | KeySize | 256 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | EllipticCurve | Name | secp256r1 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | EllipticCurve | ParsedName | secp256r1 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | EllipticCurve | RawName | secp256r1 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | Key | KeyType | Asymmetric | jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:94:61:94:68 | KeyAgreementAlgorithm | Name | X25519 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:94:61:94:68 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:94:61:94:68 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:94:61:94:68 | KeyAgreementAlgorithm | RawName | X25519 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:94:61:94:68 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:94:61:94:68 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:95:24:95:26 | Constant | Description | 255 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:95:24:95:26 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:95:24:95:26 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:96:16:96:36 | Key | KeyType | Asymmetric | jca/AsymmetricEncryptionMacHybridCryptosystem.java:96:16:96:36 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:96:16:96:36 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:109:17:109:26 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:109:17:109:26 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:109:17:109:26 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:110:20:110:28 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:110:20:110:28 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:110:20:110:28 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | HashAlgorithm | DigestSize | 256 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | HashAlgorithm | Name | SHA2 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | HashAlgorithm | RawName | SHA-256 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | KeyOperationAlgorithm | KeySize | Constant:2048 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:146:24:146:27 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:146:24:146:27 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | KeyOperationAlgorithm | Name | RSA | jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | KeyOperationAlgorithm | RawName | RSA | jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:146:24:146:27 | Constant | Description | 2048 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:146:24:146:27 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:146:24:146:27 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | Key | KeyType | Asymmetric | jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | KeyOperationAlgorithm | KeySize | Constant:1024 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:155:24:155:27 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:155:24:155:27 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | KeyOperationAlgorithm | Name | RSA | jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | KeyOperationAlgorithm | RawName | RSA | jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:155:24:155:27 | Constant | Description | 1024 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:155:24:155:27 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:155:24:155:27 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | Key | KeyType | Asymmetric | jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | HashAlgorithm | DigestSize | 256 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | HashAlgorithm | Name | SHA2 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | HashAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | KeyOperationAlgorithm | Name | RSA | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | KeyOperationAlgorithm | RawName | RSA/ECB/OAEPWithSHA-256AndMGF1Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | ModeOfOperation | Name | ECB | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | ModeOfOperation | RawName | ECB | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | PaddingAlgorithm | Name | OAEP | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | PaddingAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:167:42:167:58 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:167:42:167:58 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:167:42:167:58 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | WrapOperation | KeyOperationSubtype | Wrap | jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:9:171:40 | RandomNumberGeneration | Description | nextBytes | jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:9:171:40 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:9:171:40 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:38:171:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:38:171:39 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:38:171:39 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | KeyOperationAlgorithm | Name | AES | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | KeyOperationAlgorithm | Structure | Block | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | ModeOfOperation | Name | GCM | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | ModeOfOperation | RawName | GCM | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | PaddingAlgorithm | Name | UnknownPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | PaddingAlgorithm | RawName | NoPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:45:173:50 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:45:173:50 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:45:173:50 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | KeyOperationAlgorithm | Name | RSA | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | KeyOperationAlgorithm | RawName | RSA/ECB/PKCS1Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | ModeOfOperation | Name | ECB | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | ModeOfOperation | RawName | ECB | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | PaddingAlgorithm | Name | UnknownPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | PaddingAlgorithm | RawName | PKCS1Padding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:191:42:191:58 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:191:42:191:58 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:191:42:191:58 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | WrapOperation | KeyOperationSubtype | Wrap | jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | KeyOperationAlgorithm | Name | AES | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | KeyOperationAlgorithm | Structure | Block | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | ModeOfOperation | Name | GCM | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | ModeOfOperation | RawName | GCM | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | PaddingAlgorithm | Name | UnknownPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | PaddingAlgorithm | RawName | NoPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:45:196:50 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:45:196:50 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:45:196:50 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:215:91:215:96 | KeyAgreementAlgorithm | Name | ECDH | jca/AsymmetricEncryptionMacHybridCryptosystem.java:215:91:215:96 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:215:91:215:96 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:215:91:215:96 | KeyAgreementAlgorithm | RawName | ECDH | jca/AsymmetricEncryptionMacHybridCryptosystem.java:215:91:215:96 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:215:91:215:96 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:9:220:40 | RandomNumberGeneration | Description | nextBytes | jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:9:220:40 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:9:220:40 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:38:220:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:38:220:39 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:38:220:39 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | KeyOperationAlgorithm | Name | AES | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | KeyOperationAlgorithm | Structure | Block | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | ModeOfOperation | Name | GCM | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | ModeOfOperation | RawName | GCM | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | PaddingAlgorithm | Name | UnknownPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | PaddingAlgorithm | RawName | NoPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:42:222:47 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:42:222:47 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:42:222:47 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:239:95:239:100 | KeyAgreementAlgorithm | Name | ECDH | jca/AsymmetricEncryptionMacHybridCryptosystem.java:239:95:239:100 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:239:95:239:100 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:239:95:239:100 | KeyAgreementAlgorithm | RawName | ECDH | jca/AsymmetricEncryptionMacHybridCryptosystem.java:239:95:239:100 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:239:95:239:100 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | KeyOperationAlgorithm | Name | AES | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | KeyOperationAlgorithm | Structure | Block | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | ModeOfOperation | Name | GCM | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | ModeOfOperation | RawName | GCM | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | PaddingAlgorithm | Name | UnknownPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | PaddingAlgorithm | RawName | NoPadding | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:42:245:47 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:42:245:47 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:42:245:47 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:271:58:271:73 | Parameter | Description | plaintext | jca/AsymmetricEncryptionMacHybridCryptosystem.java:271:58:271:73 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:271:58:271:73 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | KeyOperationAlgorithm | Name | HMAC | jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:297:18:297:26 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:297:18:297:26 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:297:18:297:26 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | KeyOperationSubtype | Mac | jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | KeyOperationAlgorithm | Name | HMAC | jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | KeyOperationAlgorithm | RawName | HmacSHA1 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:308:18:308:26 | Key | KeyType | Unknown | jca/AsymmetricEncryptionMacHybridCryptosystem.java:308:18:308:26 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:308:18:308:26 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | KeyOperationSubtype | Mac | jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:321:17:321:19 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:321:17:321:19 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | KeyOperationAlgorithm | Name | AES | jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | KeyOperationAlgorithm | RawName | AES | jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | KeyOperationAlgorithm | Structure | Block | jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:321:17:321:19 | Constant | Description | 256 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:321:17:321:19 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:321:17:321:19 | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | Key | KeyType | Symmetric | jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | +| jca/ChainedEncryptionTest.java:19:44:19:62 | KeyOperationAlgorithm | Name | AES | jca/ChainedEncryptionTest.java:19:44:19:62 | jca/ChainedEncryptionTest.java:19:44:19:62 | +| jca/ChainedEncryptionTest.java:19:44:19:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/ChainedEncryptionTest.java:19:44:19:62 | jca/ChainedEncryptionTest.java:19:44:19:62 | +| jca/ChainedEncryptionTest.java:19:44:19:62 | KeyOperationAlgorithm | Structure | Block | jca/ChainedEncryptionTest.java:19:44:19:62 | jca/ChainedEncryptionTest.java:19:44:19:62 | +| jca/ChainedEncryptionTest.java:19:44:19:62 | ModeOfOperation | Name | GCM | jca/ChainedEncryptionTest.java:19:44:19:62 | jca/ChainedEncryptionTest.java:19:44:19:62 | +| jca/ChainedEncryptionTest.java:19:44:19:62 | ModeOfOperation | RawName | GCM | jca/ChainedEncryptionTest.java:19:44:19:62 | jca/ChainedEncryptionTest.java:19:44:19:62 | +| jca/ChainedEncryptionTest.java:19:44:19:62 | PaddingAlgorithm | Name | UnknownPadding | jca/ChainedEncryptionTest.java:19:44:19:62 | jca/ChainedEncryptionTest.java:19:44:19:62 | +| jca/ChainedEncryptionTest.java:19:44:19:62 | PaddingAlgorithm | RawName | NoPadding | jca/ChainedEncryptionTest.java:19:44:19:62 | jca/ChainedEncryptionTest.java:19:44:19:62 | +| jca/ChainedEncryptionTest.java:21:9:21:40 | RandomNumberGeneration | Description | nextBytes | jca/ChainedEncryptionTest.java:21:9:21:40 | jca/ChainedEncryptionTest.java:21:9:21:40 | +| jca/ChainedEncryptionTest.java:21:38:21:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/ChainedEncryptionTest.java:21:38:21:39 | jca/ChainedEncryptionTest.java:21:38:21:39 | +| jca/ChainedEncryptionTest.java:23:42:23:44 | Key | KeyType | Unknown | jca/ChainedEncryptionTest.java:23:42:23:44 | jca/ChainedEncryptionTest.java:23:42:23:44 | +| jca/ChainedEncryptionTest.java:24:29:24:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/ChainedEncryptionTest.java:24:29:24:53 | jca/ChainedEncryptionTest.java:24:29:24:53 | +| jca/ChainedEncryptionTest.java:32:44:32:62 | KeyOperationAlgorithm | Name | AES | jca/ChainedEncryptionTest.java:32:44:32:62 | jca/ChainedEncryptionTest.java:32:44:32:62 | +| jca/ChainedEncryptionTest.java:32:44:32:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/ChainedEncryptionTest.java:32:44:32:62 | jca/ChainedEncryptionTest.java:32:44:32:62 | +| jca/ChainedEncryptionTest.java:32:44:32:62 | KeyOperationAlgorithm | Structure | Block | jca/ChainedEncryptionTest.java:32:44:32:62 | jca/ChainedEncryptionTest.java:32:44:32:62 | +| jca/ChainedEncryptionTest.java:32:44:32:62 | ModeOfOperation | Name | GCM | jca/ChainedEncryptionTest.java:32:44:32:62 | jca/ChainedEncryptionTest.java:32:44:32:62 | +| jca/ChainedEncryptionTest.java:32:44:32:62 | ModeOfOperation | RawName | GCM | jca/ChainedEncryptionTest.java:32:44:32:62 | jca/ChainedEncryptionTest.java:32:44:32:62 | +| jca/ChainedEncryptionTest.java:32:44:32:62 | PaddingAlgorithm | Name | UnknownPadding | jca/ChainedEncryptionTest.java:32:44:32:62 | jca/ChainedEncryptionTest.java:32:44:32:62 | +| jca/ChainedEncryptionTest.java:32:44:32:62 | PaddingAlgorithm | RawName | NoPadding | jca/ChainedEncryptionTest.java:32:44:32:62 | jca/ChainedEncryptionTest.java:32:44:32:62 | +| jca/ChainedEncryptionTest.java:34:42:34:44 | Key | KeyType | Unknown | jca/ChainedEncryptionTest.java:34:42:34:44 | jca/ChainedEncryptionTest.java:34:42:34:44 | +| jca/ChainedEncryptionTest.java:35:16:35:41 | DecryptOperation | KeyOperationSubtype | Decrypt | jca/ChainedEncryptionTest.java:35:16:35:41 | jca/ChainedEncryptionTest.java:35:16:35:41 | +| jca/ChainedEncryptionTest.java:40:44:40:62 | KeyOperationAlgorithm | Name | Unknown | jca/ChainedEncryptionTest.java:40:44:40:62 | jca/ChainedEncryptionTest.java:40:44:40:62 | +| jca/ChainedEncryptionTest.java:40:44:40:62 | KeyOperationAlgorithm | RawName | ChaCha20-Poly1305 | jca/ChainedEncryptionTest.java:40:44:40:62 | jca/ChainedEncryptionTest.java:40:44:40:62 | +| jca/ChainedEncryptionTest.java:42:9:42:43 | RandomNumberGeneration | Description | nextBytes | jca/ChainedEncryptionTest.java:42:9:42:43 | jca/ChainedEncryptionTest.java:42:9:42:43 | +| jca/ChainedEncryptionTest.java:42:38:42:42 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/ChainedEncryptionTest.java:42:38:42:42 | jca/ChainedEncryptionTest.java:42:38:42:42 | +| jca/ChainedEncryptionTest.java:43:42:43:44 | Key | KeyType | Unknown | jca/ChainedEncryptionTest.java:43:42:43:44 | jca/ChainedEncryptionTest.java:43:42:43:44 | +| jca/ChainedEncryptionTest.java:44:29:44:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/ChainedEncryptionTest.java:44:29:44:53 | jca/ChainedEncryptionTest.java:44:29:44:53 | +| jca/ChainedEncryptionTest.java:52:44:52:62 | KeyOperationAlgorithm | Name | Unknown | jca/ChainedEncryptionTest.java:52:44:52:62 | jca/ChainedEncryptionTest.java:52:44:52:62 | +| jca/ChainedEncryptionTest.java:52:44:52:62 | KeyOperationAlgorithm | RawName | ChaCha20-Poly1305 | jca/ChainedEncryptionTest.java:52:44:52:62 | jca/ChainedEncryptionTest.java:52:44:52:62 | +| jca/ChainedEncryptionTest.java:53:42:53:44 | Key | KeyType | Unknown | jca/ChainedEncryptionTest.java:53:42:53:44 | jca/ChainedEncryptionTest.java:53:42:53:44 | +| jca/ChainedEncryptionTest.java:54:16:54:41 | DecryptOperation | KeyOperationSubtype | Decrypt | jca/ChainedEncryptionTest.java:54:16:54:41 | jca/ChainedEncryptionTest.java:54:16:54:41 | +| jca/ChainedEncryptionTest.java:75:46:75:61 | Parameter | Description | plaintext | jca/ChainedEncryptionTest.java:75:46:75:61 | jca/ChainedEncryptionTest.java:75:46:75:61 | +| jca/ChainedEncryptionTest.java:79:56:79:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/ChainedEncryptionTest.java:80:21:80:23 | jca/ChainedEncryptionTest.java:80:21:80:23 | +| jca/ChainedEncryptionTest.java:79:56:79:60 | KeyOperationAlgorithm | Name | AES | jca/ChainedEncryptionTest.java:79:56:79:60 | jca/ChainedEncryptionTest.java:79:56:79:60 | +| jca/ChainedEncryptionTest.java:79:56:79:60 | KeyOperationAlgorithm | RawName | AES | jca/ChainedEncryptionTest.java:79:56:79:60 | jca/ChainedEncryptionTest.java:79:56:79:60 | +| jca/ChainedEncryptionTest.java:79:56:79:60 | KeyOperationAlgorithm | Structure | Block | jca/ChainedEncryptionTest.java:79:56:79:60 | jca/ChainedEncryptionTest.java:79:56:79:60 | +| jca/ChainedEncryptionTest.java:80:21:80:23 | Constant | Description | 256 | jca/ChainedEncryptionTest.java:80:21:80:23 | jca/ChainedEncryptionTest.java:80:21:80:23 | +| jca/ChainedEncryptionTest.java:81:30:81:49 | Key | KeyType | Symmetric | jca/ChainedEncryptionTest.java:81:30:81:49 | jca/ChainedEncryptionTest.java:81:30:81:49 | +| jca/ChainedEncryptionTest.java:83:59:83:68 | KeyOperationAlgorithm | KeySize | 256 | jca/ChainedEncryptionTest.java:83:59:83:68 | jca/ChainedEncryptionTest.java:83:59:83:68 | +| jca/ChainedEncryptionTest.java:83:59:83:68 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/ChainedEncryptionTest.java:84:24:84:26 | jca/ChainedEncryptionTest.java:84:24:84:26 | +| jca/ChainedEncryptionTest.java:83:59:83:68 | KeyOperationAlgorithm | Name | ChaCha20 | jca/ChainedEncryptionTest.java:83:59:83:68 | jca/ChainedEncryptionTest.java:83:59:83:68 | +| jca/ChainedEncryptionTest.java:83:59:83:68 | KeyOperationAlgorithm | RawName | ChaCha20 | jca/ChainedEncryptionTest.java:83:59:83:68 | jca/ChainedEncryptionTest.java:83:59:83:68 | +| jca/ChainedEncryptionTest.java:83:59:83:68 | KeyOperationAlgorithm | Structure | Stream | jca/ChainedEncryptionTest.java:83:59:83:68 | jca/ChainedEncryptionTest.java:83:59:83:68 | +| jca/ChainedEncryptionTest.java:84:24:84:26 | Constant | Description | 256 | jca/ChainedEncryptionTest.java:84:24:84:26 | jca/ChainedEncryptionTest.java:84:24:84:26 | +| jca/ChainedEncryptionTest.java:85:30:85:52 | Key | KeyType | Symmetric | jca/ChainedEncryptionTest.java:85:30:85:52 | jca/ChainedEncryptionTest.java:85:30:85:52 | +| jca/ChainedEncryptionTest.java:89:9:89:43 | RandomNumberGeneration | Description | nextBytes | jca/ChainedEncryptionTest.java:89:9:89:43 | jca/ChainedEncryptionTest.java:89:9:89:43 | +| jca/ChainedEncryptionTest.java:89:38:89:42 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/ChainedEncryptionTest.java:89:38:89:42 | jca/ChainedEncryptionTest.java:89:38:89:42 | +| jca/ChainedEncryptionTest.java:90:47:90:65 | KeyOperationAlgorithm | Name | AES | jca/ChainedEncryptionTest.java:90:47:90:65 | jca/ChainedEncryptionTest.java:90:47:90:65 | +| jca/ChainedEncryptionTest.java:90:47:90:65 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/ChainedEncryptionTest.java:90:47:90:65 | jca/ChainedEncryptionTest.java:90:47:90:65 | +| jca/ChainedEncryptionTest.java:90:47:90:65 | KeyOperationAlgorithm | Structure | Block | jca/ChainedEncryptionTest.java:90:47:90:65 | jca/ChainedEncryptionTest.java:90:47:90:65 | +| jca/ChainedEncryptionTest.java:90:47:90:65 | ModeOfOperation | Name | GCM | jca/ChainedEncryptionTest.java:90:47:90:65 | jca/ChainedEncryptionTest.java:90:47:90:65 | +| jca/ChainedEncryptionTest.java:90:47:90:65 | ModeOfOperation | RawName | GCM | jca/ChainedEncryptionTest.java:90:47:90:65 | jca/ChainedEncryptionTest.java:90:47:90:65 | +| jca/ChainedEncryptionTest.java:90:47:90:65 | PaddingAlgorithm | Name | UnknownPadding | jca/ChainedEncryptionTest.java:90:47:90:65 | jca/ChainedEncryptionTest.java:90:47:90:65 | +| jca/ChainedEncryptionTest.java:90:47:90:65 | PaddingAlgorithm | RawName | NoPadding | jca/ChainedEncryptionTest.java:90:47:90:65 | jca/ChainedEncryptionTest.java:90:47:90:65 | +| jca/ChainedEncryptionTest.java:92:45:92:52 | Key | KeyType | Unknown | jca/ChainedEncryptionTest.java:92:45:92:52 | jca/ChainedEncryptionTest.java:92:45:92:52 | +| jca/ChainedEncryptionTest.java:93:34:93:62 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/ChainedEncryptionTest.java:93:34:93:62 | jca/ChainedEncryptionTest.java:93:34:93:62 | +| jca/ChainedEncryptionTest.java:97:9:97:49 | RandomNumberGeneration | Description | nextBytes | jca/ChainedEncryptionTest.java:97:9:97:49 | jca/ChainedEncryptionTest.java:97:9:97:49 | +| jca/ChainedEncryptionTest.java:97:38:97:48 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/ChainedEncryptionTest.java:97:38:97:48 | jca/ChainedEncryptionTest.java:97:38:97:48 | +| jca/ChainedEncryptionTest.java:98:50:98:68 | KeyOperationAlgorithm | Name | Unknown | jca/ChainedEncryptionTest.java:98:50:98:68 | jca/ChainedEncryptionTest.java:98:50:98:68 | +| jca/ChainedEncryptionTest.java:98:50:98:68 | KeyOperationAlgorithm | RawName | ChaCha20-Poly1305 | jca/ChainedEncryptionTest.java:98:50:98:68 | jca/ChainedEncryptionTest.java:98:50:98:68 | +| jca/ChainedEncryptionTest.java:99:48:99:55 | Key | KeyType | Unknown | jca/ChainedEncryptionTest.java:99:48:99:55 | jca/ChainedEncryptionTest.java:99:48:99:55 | +| jca/ChainedEncryptionTest.java:100:34:100:70 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/ChainedEncryptionTest.java:100:34:100:70 | jca/ChainedEncryptionTest.java:100:34:100:70 | +| jca/ChainedEncryptionTest.java:103:47:103:65 | KeyOperationAlgorithm | Name | Unknown | jca/ChainedEncryptionTest.java:103:47:103:65 | jca/ChainedEncryptionTest.java:103:47:103:65 | +| jca/ChainedEncryptionTest.java:103:47:103:65 | KeyOperationAlgorithm | RawName | ChaCha20-Poly1305 | jca/ChainedEncryptionTest.java:103:47:103:65 | jca/ChainedEncryptionTest.java:103:47:103:65 | +| jca/ChainedEncryptionTest.java:104:45:104:52 | Key | KeyType | Unknown | jca/ChainedEncryptionTest.java:104:45:104:52 | jca/ChainedEncryptionTest.java:104:45:104:52 | +| jca/ChainedEncryptionTest.java:105:43:105:76 | DecryptOperation | KeyOperationSubtype | Decrypt | jca/ChainedEncryptionTest.java:105:43:105:76 | jca/ChainedEncryptionTest.java:105:43:105:76 | +| jca/ChainedEncryptionTest.java:108:44:108:62 | KeyOperationAlgorithm | Name | AES | jca/ChainedEncryptionTest.java:108:44:108:62 | jca/ChainedEncryptionTest.java:108:44:108:62 | +| jca/ChainedEncryptionTest.java:108:44:108:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/ChainedEncryptionTest.java:108:44:108:62 | jca/ChainedEncryptionTest.java:108:44:108:62 | +| jca/ChainedEncryptionTest.java:108:44:108:62 | KeyOperationAlgorithm | Structure | Block | jca/ChainedEncryptionTest.java:108:44:108:62 | jca/ChainedEncryptionTest.java:108:44:108:62 | +| jca/ChainedEncryptionTest.java:108:44:108:62 | ModeOfOperation | Name | GCM | jca/ChainedEncryptionTest.java:108:44:108:62 | jca/ChainedEncryptionTest.java:108:44:108:62 | +| jca/ChainedEncryptionTest.java:108:44:108:62 | ModeOfOperation | RawName | GCM | jca/ChainedEncryptionTest.java:108:44:108:62 | jca/ChainedEncryptionTest.java:108:44:108:62 | +| jca/ChainedEncryptionTest.java:108:44:108:62 | PaddingAlgorithm | Name | UnknownPadding | jca/ChainedEncryptionTest.java:108:44:108:62 | jca/ChainedEncryptionTest.java:108:44:108:62 | +| jca/ChainedEncryptionTest.java:108:44:108:62 | PaddingAlgorithm | RawName | NoPadding | jca/ChainedEncryptionTest.java:108:44:108:62 | jca/ChainedEncryptionTest.java:108:44:108:62 | +| jca/ChainedEncryptionTest.java:109:42:109:49 | Key | KeyType | Unknown | jca/ChainedEncryptionTest.java:109:42:109:49 | jca/ChainedEncryptionTest.java:109:42:109:49 | +| jca/ChainedEncryptionTest.java:110:37:110:76 | DecryptOperation | KeyOperationSubtype | Decrypt | jca/ChainedEncryptionTest.java:110:37:110:76 | jca/ChainedEncryptionTest.java:110:37:110:76 | +| jca/ChainedEncryptionTest.java:117:56:117:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/ChainedEncryptionTest.java:118:21:118:23 | jca/ChainedEncryptionTest.java:118:21:118:23 | +| jca/ChainedEncryptionTest.java:117:56:117:60 | KeyOperationAlgorithm | Name | AES | jca/ChainedEncryptionTest.java:117:56:117:60 | jca/ChainedEncryptionTest.java:117:56:117:60 | +| jca/ChainedEncryptionTest.java:117:56:117:60 | KeyOperationAlgorithm | RawName | AES | jca/ChainedEncryptionTest.java:117:56:117:60 | jca/ChainedEncryptionTest.java:117:56:117:60 | +| jca/ChainedEncryptionTest.java:117:56:117:60 | KeyOperationAlgorithm | Structure | Block | jca/ChainedEncryptionTest.java:117:56:117:60 | jca/ChainedEncryptionTest.java:117:56:117:60 | +| jca/ChainedEncryptionTest.java:118:21:118:23 | Constant | Description | 256 | jca/ChainedEncryptionTest.java:118:21:118:23 | jca/ChainedEncryptionTest.java:118:21:118:23 | +| jca/ChainedEncryptionTest.java:119:28:119:47 | Key | KeyType | Symmetric | jca/ChainedEncryptionTest.java:119:28:119:47 | jca/ChainedEncryptionTest.java:119:28:119:47 | +| jca/ChainedEncryptionTest.java:122:59:122:68 | KeyOperationAlgorithm | KeySize | 256 | jca/ChainedEncryptionTest.java:122:59:122:68 | jca/ChainedEncryptionTest.java:122:59:122:68 | +| jca/ChainedEncryptionTest.java:122:59:122:68 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/ChainedEncryptionTest.java:123:24:123:26 | jca/ChainedEncryptionTest.java:123:24:123:26 | +| jca/ChainedEncryptionTest.java:122:59:122:68 | KeyOperationAlgorithm | Name | ChaCha20 | jca/ChainedEncryptionTest.java:122:59:122:68 | jca/ChainedEncryptionTest.java:122:59:122:68 | +| jca/ChainedEncryptionTest.java:122:59:122:68 | KeyOperationAlgorithm | RawName | ChaCha20 | jca/ChainedEncryptionTest.java:122:59:122:68 | jca/ChainedEncryptionTest.java:122:59:122:68 | +| jca/ChainedEncryptionTest.java:122:59:122:68 | KeyOperationAlgorithm | Structure | Stream | jca/ChainedEncryptionTest.java:122:59:122:68 | jca/ChainedEncryptionTest.java:122:59:122:68 | +| jca/ChainedEncryptionTest.java:123:24:123:26 | Constant | Description | 256 | jca/ChainedEncryptionTest.java:123:24:123:26 | jca/ChainedEncryptionTest.java:123:24:123:26 | +| jca/ChainedEncryptionTest.java:124:31:124:53 | Key | KeyType | Symmetric | jca/ChainedEncryptionTest.java:124:31:124:53 | jca/ChainedEncryptionTest.java:124:31:124:53 | +| jca/ChainedEncryptionTest.java:126:31:126:57 | Constant | Description | "This is a secret message." | jca/ChainedEncryptionTest.java:126:31:126:57 | jca/ChainedEncryptionTest.java:126:31:126:57 | +| jca/Digest.java:54:58:54:66 | HashAlgorithm | DigestSize | 256 | jca/Digest.java:54:58:54:66 | jca/Digest.java:54:58:54:66 | +| jca/Digest.java:54:58:54:66 | HashAlgorithm | Name | SHA2 | jca/Digest.java:54:58:54:66 | jca/Digest.java:54:58:54:66 | +| jca/Digest.java:54:58:54:66 | HashAlgorithm | RawName | SHA-256 | jca/Digest.java:54:58:54:66 | jca/Digest.java:54:58:54:66 | +| jca/Digest.java:55:37:55:54 | Constant | Description | "Simple Test Data" | jca/Digest.java:55:37:55:54 | jca/Digest.java:55:37:55:54 | +| jca/Digest.java:64:61:64:65 | HashAlgorithm | DigestSize | 128 | jca/Digest.java:64:61:64:65 | jca/Digest.java:64:61:64:65 | +| jca/Digest.java:64:61:64:65 | HashAlgorithm | Name | MD5 | jca/Digest.java:64:61:64:65 | jca/Digest.java:64:61:64:65 | +| jca/Digest.java:64:61:64:65 | HashAlgorithm | RawName | MD5 | jca/Digest.java:64:61:64:65 | jca/Digest.java:64:61:64:65 | +| jca/Digest.java:65:40:65:58 | Constant | Description | "Weak Hash Example" | jca/Digest.java:65:40:65:58 | jca/Digest.java:65:40:65:58 | +| jca/Digest.java:73:49:73:63 | Parameter | Description | password | jca/Digest.java:73:49:73:63 | jca/Digest.java:73:49:73:63 | +| jca/Digest.java:74:64:74:72 | HashAlgorithm | DigestSize | 256 | jca/Digest.java:74:64:74:72 | jca/Digest.java:74:64:74:72 | +| jca/Digest.java:74:64:74:72 | HashAlgorithm | Name | SHA2 | jca/Digest.java:74:64:74:72 | jca/Digest.java:74:64:74:72 | +| jca/Digest.java:74:64:74:72 | HashAlgorithm | RawName | SHA-256 | jca/Digest.java:74:64:74:72 | jca/Digest.java:74:64:74:72 | +| jca/Digest.java:83:37:83:51 | Parameter | Description | password | jca/Digest.java:83:37:83:51 | jca/Digest.java:83:37:83:51 | +| jca/Digest.java:85:58:85:66 | HashAlgorithm | DigestSize | 256 | jca/Digest.java:85:58:85:66 | jca/Digest.java:85:58:85:66 | +| jca/Digest.java:85:58:85:66 | HashAlgorithm | Name | SHA2 | jca/Digest.java:85:58:85:66 | jca/Digest.java:85:58:85:66 | +| jca/Digest.java:85:58:85:66 | HashAlgorithm | RawName | SHA-256 | jca/Digest.java:85:58:85:66 | jca/Digest.java:85:58:85:66 | +| jca/Digest.java:95:37:95:51 | Parameter | Description | password | jca/Digest.java:95:37:95:51 | jca/Digest.java:95:37:95:51 | +| jca/Digest.java:97:72:97:76 | Constant | Description | 10000 | jca/Digest.java:97:72:97:76 | jca/Digest.java:97:72:97:76 | +| jca/Digest.java:97:79:97:81 | Constant | Description | 256 | jca/Digest.java:97:79:97:81 | jca/Digest.java:97:79:97:81 | +| jca/Digest.java:98:65:98:86 | HMACAlgorithm | Name | HMAC | jca/Digest.java:98:65:98:86 | jca/Digest.java:98:65:98:86 | +| jca/Digest.java:98:65:98:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/Digest.java:98:65:98:86 | jca/Digest.java:98:65:98:86 | +| jca/Digest.java:98:65:98:86 | HashAlgorithm | DigestSize | 256 | jca/Digest.java:98:65:98:86 | jca/Digest.java:98:65:98:86 | +| jca/Digest.java:98:65:98:86 | HashAlgorithm | Name | SHA2 | jca/Digest.java:98:65:98:86 | jca/Digest.java:98:65:98:86 | +| jca/Digest.java:98:65:98:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/Digest.java:98:65:98:86 | jca/Digest.java:98:65:98:86 | +| jca/Digest.java:98:65:98:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/Digest.java:98:65:98:86 | jca/Digest.java:98:65:98:86 | +| jca/Digest.java:98:65:98:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/Digest.java:98:65:98:86 | jca/Digest.java:98:65:98:86 | +| jca/Digest.java:99:23:99:50 | Key | KeyType | Symmetric | jca/Digest.java:99:23:99:50 | jca/Digest.java:99:23:99:50 | +| jca/Digest.java:99:23:99:50 | KeyDerivation | Iterations | Constant:10000 | jca/Digest.java:97:72:97:76 | jca/Digest.java:97:72:97:76 | +| jca/Digest.java:99:23:99:50 | KeyDerivation | KeySize | Constant:256 | jca/Digest.java:97:79:97:81 | jca/Digest.java:97:79:97:81 | +| jca/Digest.java:107:40:107:51 | Parameter | Description | input | jca/Digest.java:107:40:107:51 | jca/Digest.java:107:40:107:51 | +| jca/Digest.java:108:62:108:68 | HashAlgorithm | DigestSize | 160 | jca/Digest.java:108:62:108:68 | jca/Digest.java:108:62:108:68 | +| jca/Digest.java:108:62:108:68 | HashAlgorithm | Name | SHA1 | jca/Digest.java:108:62:108:68 | jca/Digest.java:108:62:108:68 | +| jca/Digest.java:108:62:108:68 | HashAlgorithm | RawName | SHA-1 | jca/Digest.java:108:62:108:68 | jca/Digest.java:108:62:108:68 | +| jca/Digest.java:117:35:117:46 | Parameter | Description | input | jca/Digest.java:117:35:117:46 | jca/Digest.java:117:35:117:46 | +| jca/Digest.java:117:49:117:58 | Parameter | Description | key | jca/Digest.java:117:49:117:58 | jca/Digest.java:117:49:117:58 | +| jca/Digest.java:118:36:118:47 | KeyOperationAlgorithm | Name | HMAC | jca/Digest.java:118:36:118:47 | jca/Digest.java:118:36:118:47 | +| jca/Digest.java:118:36:118:47 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/Digest.java:118:36:118:47 | jca/Digest.java:118:36:118:47 | +| jca/Digest.java:120:19:120:27 | Key | KeyType | Unknown | jca/Digest.java:120:19:120:27 | jca/Digest.java:120:19:120:27 | +| jca/Digest.java:121:23:121:52 | MACOperation | KeyOperationSubtype | Mac | jca/Digest.java:121:23:121:52 | jca/Digest.java:121:23:121:52 | +| jca/Digest.java:140:44:140:62 | KeyOperationAlgorithm | Name | AES | jca/Digest.java:140:44:140:62 | jca/Digest.java:140:44:140:62 | +| jca/Digest.java:140:44:140:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/Digest.java:140:44:140:62 | jca/Digest.java:140:44:140:62 | +| jca/Digest.java:140:44:140:62 | KeyOperationAlgorithm | Structure | Block | jca/Digest.java:140:44:140:62 | jca/Digest.java:140:44:140:62 | +| jca/Digest.java:140:44:140:62 | ModeOfOperation | Name | GCM | jca/Digest.java:140:44:140:62 | jca/Digest.java:140:44:140:62 | +| jca/Digest.java:140:44:140:62 | ModeOfOperation | RawName | GCM | jca/Digest.java:140:44:140:62 | jca/Digest.java:140:44:140:62 | +| jca/Digest.java:140:44:140:62 | PaddingAlgorithm | Name | UnknownPadding | jca/Digest.java:140:44:140:62 | jca/Digest.java:140:44:140:62 | +| jca/Digest.java:140:44:140:62 | PaddingAlgorithm | RawName | NoPadding | jca/Digest.java:140:44:140:62 | jca/Digest.java:140:44:140:62 | +| jca/Digest.java:141:42:141:44 | Key | KeyType | Unknown | jca/Digest.java:141:42:141:44 | jca/Digest.java:141:42:141:44 | +| jca/Digest.java:142:32:142:74 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Digest.java:142:32:142:74 | jca/Digest.java:142:32:142:74 | +| jca/Digest.java:142:47:142:62 | Constant | Description | "Sensitive Data" | jca/Digest.java:142:47:142:62 | jca/Digest.java:142:47:142:62 | +| jca/Digest.java:155:39:155:51 | Parameter | Description | digest | jca/Digest.java:155:39:155:51 | jca/Digest.java:155:39:155:51 | +| jca/Digest.java:171:50:171:62 | Parameter | Description | digest | jca/Digest.java:171:50:171:62 | jca/Digest.java:171:50:171:62 | +| jca/Digest.java:176:80:176:84 | Constant | Description | 10000 | jca/Digest.java:176:80:176:84 | jca/Digest.java:176:80:176:84 | +| jca/Digest.java:176:87:176:89 | Constant | Description | 256 | jca/Digest.java:176:87:176:89 | jca/Digest.java:176:87:176:89 | +| jca/Digest.java:177:65:177:86 | HMACAlgorithm | Name | HMAC | jca/Digest.java:177:65:177:86 | jca/Digest.java:177:65:177:86 | +| jca/Digest.java:177:65:177:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/Digest.java:177:65:177:86 | jca/Digest.java:177:65:177:86 | +| jca/Digest.java:177:65:177:86 | HashAlgorithm | DigestSize | 256 | jca/Digest.java:177:65:177:86 | jca/Digest.java:177:65:177:86 | +| jca/Digest.java:177:65:177:86 | HashAlgorithm | Name | SHA2 | jca/Digest.java:177:65:177:86 | jca/Digest.java:177:65:177:86 | +| jca/Digest.java:177:65:177:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/Digest.java:177:65:177:86 | jca/Digest.java:177:65:177:86 | +| jca/Digest.java:177:65:177:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/Digest.java:177:65:177:86 | jca/Digest.java:177:65:177:86 | +| jca/Digest.java:177:65:177:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/Digest.java:177:65:177:86 | jca/Digest.java:177:65:177:86 | +| jca/Digest.java:178:30:178:57 | Key | KeyType | Symmetric | jca/Digest.java:178:30:178:57 | jca/Digest.java:178:30:178:57 | +| jca/Digest.java:178:30:178:57 | KeyDerivation | Iterations | Constant:10000 | jca/Digest.java:176:80:176:84 | jca/Digest.java:176:80:176:84 | +| jca/Digest.java:178:30:178:57 | KeyDerivation | KeySize | Constant:256 | jca/Digest.java:176:87:176:89 | jca/Digest.java:176:87:176:89 | +| jca/Digest.java:186:44:186:62 | KeyOperationAlgorithm | Name | AES | jca/Digest.java:186:44:186:62 | jca/Digest.java:186:44:186:62 | +| jca/Digest.java:186:44:186:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/Digest.java:186:44:186:62 | jca/Digest.java:186:44:186:62 | +| jca/Digest.java:186:44:186:62 | KeyOperationAlgorithm | Structure | Block | jca/Digest.java:186:44:186:62 | jca/Digest.java:186:44:186:62 | +| jca/Digest.java:186:44:186:62 | ModeOfOperation | Name | GCM | jca/Digest.java:186:44:186:62 | jca/Digest.java:186:44:186:62 | +| jca/Digest.java:186:44:186:62 | ModeOfOperation | RawName | GCM | jca/Digest.java:186:44:186:62 | jca/Digest.java:186:44:186:62 | +| jca/Digest.java:186:44:186:62 | PaddingAlgorithm | Name | UnknownPadding | jca/Digest.java:186:44:186:62 | jca/Digest.java:186:44:186:62 | +| jca/Digest.java:186:44:186:62 | PaddingAlgorithm | RawName | NoPadding | jca/Digest.java:186:44:186:62 | jca/Digest.java:186:44:186:62 | +| jca/Digest.java:187:42:187:54 | Key | KeyType | Unknown | jca/Digest.java:187:42:187:54 | jca/Digest.java:187:42:187:54 | +| jca/Digest.java:188:29:188:78 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Digest.java:188:29:188:78 | jca/Digest.java:188:29:188:78 | +| jca/Digest.java:188:44:188:66 | Constant | Description | "Further Use Test Data" | jca/Digest.java:188:44:188:66 | jca/Digest.java:188:44:188:66 | +| jca/Digest.java:191:35:191:46 | KeyOperationAlgorithm | Name | HMAC | jca/Digest.java:191:35:191:46 | jca/Digest.java:191:35:191:46 | +| jca/Digest.java:191:35:191:46 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/Digest.java:191:35:191:46 | jca/Digest.java:191:35:191:46 | +| jca/Digest.java:192:18:192:23 | Key | KeyType | Unknown | jca/Digest.java:192:18:192:23 | jca/Digest.java:192:18:192:23 | +| jca/Digest.java:193:30:193:52 | MACOperation | KeyOperationSubtype | Mac | jca/Digest.java:193:30:193:52 | jca/Digest.java:193:30:193:52 | +| jca/Digest.java:210:44:210:62 | KeyOperationAlgorithm | Name | AES | jca/Digest.java:210:44:210:62 | jca/Digest.java:210:44:210:62 | +| jca/Digest.java:210:44:210:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/Digest.java:210:44:210:62 | jca/Digest.java:210:44:210:62 | +| jca/Digest.java:210:44:210:62 | KeyOperationAlgorithm | Structure | Block | jca/Digest.java:210:44:210:62 | jca/Digest.java:210:44:210:62 | +| jca/Digest.java:210:44:210:62 | ModeOfOperation | Name | GCM | jca/Digest.java:210:44:210:62 | jca/Digest.java:210:44:210:62 | +| jca/Digest.java:210:44:210:62 | ModeOfOperation | RawName | GCM | jca/Digest.java:210:44:210:62 | jca/Digest.java:210:44:210:62 | +| jca/Digest.java:210:44:210:62 | PaddingAlgorithm | Name | UnknownPadding | jca/Digest.java:210:44:210:62 | jca/Digest.java:210:44:210:62 | +| jca/Digest.java:210:44:210:62 | PaddingAlgorithm | RawName | NoPadding | jca/Digest.java:210:44:210:62 | jca/Digest.java:210:44:210:62 | +| jca/Digest.java:212:42:212:44 | Key | KeyType | Unknown | jca/Digest.java:212:42:212:44 | jca/Digest.java:212:42:212:44 | +| jca/Digest.java:213:32:213:51 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Digest.java:213:32:213:51 | jca/Digest.java:213:32:213:51 | +| jca/Digest.java:239:56:239:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/Digest.java:240:21:240:23 | jca/Digest.java:240:21:240:23 | +| jca/Digest.java:239:56:239:60 | KeyOperationAlgorithm | Name | AES | jca/Digest.java:239:56:239:60 | jca/Digest.java:239:56:239:60 | +| jca/Digest.java:239:56:239:60 | KeyOperationAlgorithm | RawName | AES | jca/Digest.java:239:56:239:60 | jca/Digest.java:239:56:239:60 | +| jca/Digest.java:239:56:239:60 | KeyOperationAlgorithm | Structure | Block | jca/Digest.java:239:56:239:60 | jca/Digest.java:239:56:239:60 | +| jca/Digest.java:240:21:240:23 | Constant | Description | 256 | jca/Digest.java:240:21:240:23 | jca/Digest.java:240:21:240:23 | +| jca/Digest.java:241:16:241:35 | Key | KeyType | Symmetric | jca/Digest.java:241:16:241:35 | jca/Digest.java:241:16:241:35 | +| jca/Digest.java:253:9:253:42 | RandomNumberGeneration | Description | nextBytes | jca/Digest.java:253:9:253:42 | jca/Digest.java:253:9:253:42 | +| jca/Digest.java:253:38:253:41 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/Digest.java:253:38:253:41 | jca/Digest.java:253:38:253:41 | +| jca/EllipticCurve1.java:46:66:46:76 | EllipticCurve | KeySize | 256 | jca/EllipticCurve1.java:46:66:46:76 | jca/EllipticCurve1.java:46:66:46:76 | +| jca/EllipticCurve1.java:46:66:46:76 | EllipticCurve | Name | secp256r1 | jca/EllipticCurve1.java:46:66:46:76 | jca/EllipticCurve1.java:46:66:46:76 | +| jca/EllipticCurve1.java:46:66:46:76 | EllipticCurve | ParsedName | secp256r1 | jca/EllipticCurve1.java:46:66:46:76 | jca/EllipticCurve1.java:46:66:46:76 | +| jca/EllipticCurve1.java:46:66:46:76 | EllipticCurve | RawName | secp256r1 | jca/EllipticCurve1.java:46:66:46:76 | jca/EllipticCurve1.java:46:66:46:76 | +| jca/EllipticCurve1.java:47:16:47:36 | Key | KeyType | Asymmetric | jca/EllipticCurve1.java:47:16:47:36 | jca/EllipticCurve1.java:47:16:47:36 | +| jca/EllipticCurve1.java:56:66:56:76 | EllipticCurve | KeySize | 256 | jca/EllipticCurve1.java:56:66:56:76 | jca/EllipticCurve1.java:56:66:56:76 | +| jca/EllipticCurve1.java:56:66:56:76 | EllipticCurve | Name | secp256k1 | jca/EllipticCurve1.java:56:66:56:76 | jca/EllipticCurve1.java:56:66:56:76 | +| jca/EllipticCurve1.java:56:66:56:76 | EllipticCurve | ParsedName | secp256k1 | jca/EllipticCurve1.java:56:66:56:76 | jca/EllipticCurve1.java:56:66:56:76 | +| jca/EllipticCurve1.java:56:66:56:76 | EllipticCurve | RawName | secp256k1 | jca/EllipticCurve1.java:56:66:56:76 | jca/EllipticCurve1.java:56:66:56:76 | +| jca/EllipticCurve1.java:57:16:57:36 | Key | KeyType | Asymmetric | jca/EllipticCurve1.java:57:16:57:36 | jca/EllipticCurve1.java:57:16:57:36 | +| jca/EllipticCurve1.java:66:66:66:82 | EllipticCurve | KeySize | 256 | jca/EllipticCurve1.java:66:66:66:82 | jca/EllipticCurve1.java:66:66:66:82 | +| jca/EllipticCurve1.java:66:66:66:82 | EllipticCurve | Name | brainpoolP256r1 | jca/EllipticCurve1.java:66:66:66:82 | jca/EllipticCurve1.java:66:66:66:82 | +| jca/EllipticCurve1.java:66:66:66:82 | EllipticCurve | ParsedName | brainpoolP256r1 | jca/EllipticCurve1.java:66:66:66:82 | jca/EllipticCurve1.java:66:66:66:82 | +| jca/EllipticCurve1.java:66:66:66:82 | EllipticCurve | RawName | brainpoolP256r1 | jca/EllipticCurve1.java:66:66:66:82 | jca/EllipticCurve1.java:66:66:66:82 | +| jca/EllipticCurve1.java:67:16:67:36 | Key | KeyType | Asymmetric | jca/EllipticCurve1.java:67:16:67:36 | jca/EllipticCurve1.java:67:16:67:36 | +| jca/EllipticCurve1.java:74:61:74:68 | KeyAgreementAlgorithm | Name | X25519 | jca/EllipticCurve1.java:74:61:74:68 | jca/EllipticCurve1.java:74:61:74:68 | +| jca/EllipticCurve1.java:74:61:74:68 | KeyAgreementAlgorithm | RawName | X25519 | jca/EllipticCurve1.java:74:61:74:68 | jca/EllipticCurve1.java:74:61:74:68 | +| jca/EllipticCurve1.java:76:16:76:36 | Key | KeyType | Asymmetric | jca/EllipticCurve1.java:76:16:76:36 | jca/EllipticCurve1.java:76:16:76:36 | +| jca/EllipticCurve1.java:83:61:83:66 | KeyAgreementAlgorithm | Name | X448 | jca/EllipticCurve1.java:83:61:83:66 | jca/EllipticCurve1.java:83:61:83:66 | +| jca/EllipticCurve1.java:83:61:83:66 | KeyAgreementAlgorithm | RawName | X448 | jca/EllipticCurve1.java:83:61:83:66 | jca/EllipticCurve1.java:83:61:83:66 | +| jca/EllipticCurve1.java:84:16:84:36 | Key | KeyType | Asymmetric | jca/EllipticCurve1.java:84:16:84:36 | jca/EllipticCurve1.java:84:16:84:36 | +| jca/EllipticCurve1.java:94:66:94:76 | EllipticCurve | KeySize | 163 | jca/EllipticCurve1.java:94:66:94:76 | jca/EllipticCurve1.java:94:66:94:76 | +| jca/EllipticCurve1.java:94:66:94:76 | EllipticCurve | Name | sect163r2 | jca/EllipticCurve1.java:94:66:94:76 | jca/EllipticCurve1.java:94:66:94:76 | +| jca/EllipticCurve1.java:94:66:94:76 | EllipticCurve | ParsedName | sect163r2 | jca/EllipticCurve1.java:94:66:94:76 | jca/EllipticCurve1.java:94:66:94:76 | +| jca/EllipticCurve1.java:94:66:94:76 | EllipticCurve | RawName | sect163r2 | jca/EllipticCurve1.java:94:66:94:76 | jca/EllipticCurve1.java:94:66:94:76 | +| jca/EllipticCurve1.java:95:16:95:36 | Key | KeyType | Asymmetric | jca/EllipticCurve1.java:95:16:95:36 | jca/EllipticCurve1.java:95:16:95:36 | +| jca/EllipticCurve1.java:105:66:105:76 | Constant | Description | "sm2p256v1" | jca/EllipticCurve1.java:105:66:105:76 | jca/EllipticCurve1.java:105:66:105:76 | +| jca/EllipticCurve1.java:106:16:106:36 | Key | KeyType | Asymmetric | jca/EllipticCurve1.java:106:16:106:36 | jca/EllipticCurve1.java:106:16:106:36 | +| jca/EllipticCurve1.java:114:61:114:69 | Constant | Description | "Ed25519" | jca/EllipticCurve1.java:114:61:114:69 | jca/EllipticCurve1.java:114:61:114:69 | +| jca/EllipticCurve1.java:115:16:115:36 | Key | KeyType | Asymmetric | jca/EllipticCurve1.java:115:16:115:36 | jca/EllipticCurve1.java:115:16:115:36 | +| jca/EllipticCurve2.java:46:47:46:57 | EllipticCurve | KeySize | 256 | jca/EllipticCurve2.java:46:47:46:57 | jca/EllipticCurve2.java:46:47:46:57 | +| jca/EllipticCurve2.java:46:47:46:57 | EllipticCurve | Name | secp256r1 | jca/EllipticCurve2.java:46:47:46:57 | jca/EllipticCurve2.java:46:47:46:57 | +| jca/EllipticCurve2.java:46:47:46:57 | EllipticCurve | ParsedName | secp256r1 | jca/EllipticCurve2.java:46:47:46:57 | jca/EllipticCurve2.java:46:47:46:57 | +| jca/EllipticCurve2.java:46:47:46:57 | EllipticCurve | RawName | secp256r1 | jca/EllipticCurve2.java:46:47:46:57 | jca/EllipticCurve2.java:46:47:46:57 | +| jca/EllipticCurve2.java:47:16:47:36 | Key | KeyType | Asymmetric | jca/EllipticCurve2.java:47:16:47:36 | jca/EllipticCurve2.java:47:16:47:36 | +| jca/EllipticCurve2.java:55:47:55:57 | EllipticCurve | KeySize | 256 | jca/EllipticCurve2.java:55:47:55:57 | jca/EllipticCurve2.java:55:47:55:57 | +| jca/EllipticCurve2.java:55:47:55:57 | EllipticCurve | Name | secp256k1 | jca/EllipticCurve2.java:55:47:55:57 | jca/EllipticCurve2.java:55:47:55:57 | +| jca/EllipticCurve2.java:55:47:55:57 | EllipticCurve | ParsedName | secp256k1 | jca/EllipticCurve2.java:55:47:55:57 | jca/EllipticCurve2.java:55:47:55:57 | +| jca/EllipticCurve2.java:55:47:55:57 | EllipticCurve | RawName | secp256k1 | jca/EllipticCurve2.java:55:47:55:57 | jca/EllipticCurve2.java:55:47:55:57 | +| jca/EllipticCurve2.java:56:16:56:36 | Key | KeyType | Asymmetric | jca/EllipticCurve2.java:56:16:56:36 | jca/EllipticCurve2.java:56:16:56:36 | +| jca/EllipticCurve2.java:64:47:64:63 | EllipticCurve | KeySize | 256 | jca/EllipticCurve2.java:64:47:64:63 | jca/EllipticCurve2.java:64:47:64:63 | +| jca/EllipticCurve2.java:64:47:64:63 | EllipticCurve | Name | brainpoolP256r1 | jca/EllipticCurve2.java:64:47:64:63 | jca/EllipticCurve2.java:64:47:64:63 | +| jca/EllipticCurve2.java:64:47:64:63 | EllipticCurve | ParsedName | brainpoolP256r1 | jca/EllipticCurve2.java:64:47:64:63 | jca/EllipticCurve2.java:64:47:64:63 | +| jca/EllipticCurve2.java:64:47:64:63 | EllipticCurve | RawName | brainpoolP256r1 | jca/EllipticCurve2.java:64:47:64:63 | jca/EllipticCurve2.java:64:47:64:63 | +| jca/EllipticCurve2.java:65:16:65:36 | Key | KeyType | Asymmetric | jca/EllipticCurve2.java:65:16:65:36 | jca/EllipticCurve2.java:65:16:65:36 | +| jca/EllipticCurve2.java:72:61:72:68 | KeyAgreementAlgorithm | Name | X25519 | jca/EllipticCurve2.java:72:61:72:68 | jca/EllipticCurve2.java:72:61:72:68 | +| jca/EllipticCurve2.java:72:61:72:68 | KeyAgreementAlgorithm | RawName | X25519 | jca/EllipticCurve2.java:72:61:72:68 | jca/EllipticCurve2.java:72:61:72:68 | +| jca/EllipticCurve2.java:73:16:73:36 | Key | KeyType | Asymmetric | jca/EllipticCurve2.java:73:16:73:36 | jca/EllipticCurve2.java:73:16:73:36 | +| jca/EllipticCurve2.java:80:61:80:69 | Constant | Description | "Ed25519" | jca/EllipticCurve2.java:80:61:80:69 | jca/EllipticCurve2.java:80:61:80:69 | +| jca/EllipticCurve2.java:81:16:81:36 | Key | KeyType | Asymmetric | jca/EllipticCurve2.java:81:16:81:36 | jca/EllipticCurve2.java:81:16:81:36 | +| jca/EllipticCurve2.java:105:52:105:57 | KeyAgreementAlgorithm | Name | ECDH | jca/EllipticCurve2.java:105:52:105:57 | jca/EllipticCurve2.java:105:52:105:57 | +| jca/EllipticCurve2.java:105:52:105:57 | KeyAgreementAlgorithm | RawName | ECDH | jca/EllipticCurve2.java:105:52:105:57 | jca/EllipticCurve2.java:105:52:105:57 | +| jca/EllipticCurve2.java:106:17:106:36 | Key | KeyType | Unknown | jca/EllipticCurve2.java:106:17:106:36 | jca/EllipticCurve2.java:106:17:106:36 | +| jca/EllipticCurve2.java:107:20:107:36 | Key | KeyType | Unknown | jca/EllipticCurve2.java:107:20:107:36 | jca/EllipticCurve2.java:107:20:107:36 | +| jca/EllipticCurve2.java:119:52:119:57 | KeyAgreementAlgorithm | Name | ECDH | jca/EllipticCurve2.java:119:52:119:57 | jca/EllipticCurve2.java:119:52:119:57 | +| jca/EllipticCurve2.java:119:52:119:57 | KeyAgreementAlgorithm | RawName | ECDH | jca/EllipticCurve2.java:119:52:119:57 | jca/EllipticCurve2.java:119:52:119:57 | +| jca/EllipticCurve2.java:120:17:120:37 | Key | KeyType | Unknown | jca/EllipticCurve2.java:120:17:120:37 | jca/EllipticCurve2.java:120:17:120:37 | +| jca/EllipticCurve2.java:121:20:121:39 | Key | KeyType | Unknown | jca/EllipticCurve2.java:121:20:121:39 | jca/EllipticCurve2.java:121:20:121:39 | +| jca/EllipticCurve2.java:136:53:136:69 | HashAlgorithm | DigestSize | 256 | jca/EllipticCurve2.java:136:53:136:69 | jca/EllipticCurve2.java:136:53:136:69 | +| jca/EllipticCurve2.java:136:53:136:69 | HashAlgorithm | Name | SHA2 | jca/EllipticCurve2.java:136:53:136:69 | jca/EllipticCurve2.java:136:53:136:69 | +| jca/EllipticCurve2.java:136:53:136:69 | HashAlgorithm | RawName | SHA256withECDSA | jca/EllipticCurve2.java:136:53:136:69 | jca/EllipticCurve2.java:136:53:136:69 | +| jca/EllipticCurve2.java:136:53:136:69 | KeyOperationAlgorithm | Name | ECDSA | jca/EllipticCurve2.java:136:53:136:69 | jca/EllipticCurve2.java:136:53:136:69 | +| jca/EllipticCurve2.java:136:53:136:69 | KeyOperationAlgorithm | RawName | SHA256withECDSA | jca/EllipticCurve2.java:136:53:136:69 | jca/EllipticCurve2.java:136:53:136:69 | +| jca/EllipticCurve2.java:137:28:137:42 | Key | KeyType | Unknown | jca/EllipticCurve2.java:137:28:137:42 | jca/EllipticCurve2.java:137:28:137:42 | +| jca/EllipticCurve2.java:139:16:139:31 | SignOperation | KeyOperationSubtype | Sign | jca/EllipticCurve2.java:139:16:139:31 | jca/EllipticCurve2.java:139:16:139:31 | +| jca/EllipticCurve2.java:151:53:151:69 | HashAlgorithm | DigestSize | 256 | jca/EllipticCurve2.java:151:53:151:69 | jca/EllipticCurve2.java:151:53:151:69 | +| jca/EllipticCurve2.java:151:53:151:69 | HashAlgorithm | Name | SHA2 | jca/EllipticCurve2.java:151:53:151:69 | jca/EllipticCurve2.java:151:53:151:69 | +| jca/EllipticCurve2.java:151:53:151:69 | HashAlgorithm | RawName | SHA256withECDSA | jca/EllipticCurve2.java:151:53:151:69 | jca/EllipticCurve2.java:151:53:151:69 | +| jca/EllipticCurve2.java:151:53:151:69 | KeyOperationAlgorithm | Name | ECDSA | jca/EllipticCurve2.java:151:53:151:69 | jca/EllipticCurve2.java:151:53:151:69 | +| jca/EllipticCurve2.java:151:53:151:69 | KeyOperationAlgorithm | RawName | SHA256withECDSA | jca/EllipticCurve2.java:151:53:151:69 | jca/EllipticCurve2.java:151:53:151:69 | +| jca/EllipticCurve2.java:152:30:152:43 | Key | KeyType | Unknown | jca/EllipticCurve2.java:152:30:152:43 | jca/EllipticCurve2.java:152:30:152:43 | +| jca/EllipticCurve2.java:154:16:154:47 | VerifyOperation | KeyOperationSubtype | Verify | jca/EllipticCurve2.java:154:16:154:47 | jca/EllipticCurve2.java:154:16:154:47 | +| jca/EllipticCurve2.java:166:53:166:61 | KeyOperationAlgorithm | Name | EDSA | jca/EllipticCurve2.java:166:53:166:61 | jca/EllipticCurve2.java:166:53:166:61 | +| jca/EllipticCurve2.java:166:53:166:61 | KeyOperationAlgorithm | RawName | Ed25519 | jca/EllipticCurve2.java:166:53:166:61 | jca/EllipticCurve2.java:166:53:166:61 | +| jca/EllipticCurve2.java:167:28:167:42 | Key | KeyType | Unknown | jca/EllipticCurve2.java:167:28:167:42 | jca/EllipticCurve2.java:167:28:167:42 | +| jca/EllipticCurve2.java:169:16:169:31 | SignOperation | KeyOperationSubtype | Sign | jca/EllipticCurve2.java:169:16:169:31 | jca/EllipticCurve2.java:169:16:169:31 | +| jca/EllipticCurve2.java:181:53:181:61 | KeyOperationAlgorithm | Name | EDSA | jca/EllipticCurve2.java:181:53:181:61 | jca/EllipticCurve2.java:181:53:181:61 | +| jca/EllipticCurve2.java:181:53:181:61 | KeyOperationAlgorithm | RawName | Ed25519 | jca/EllipticCurve2.java:181:53:181:61 | jca/EllipticCurve2.java:181:53:181:61 | +| jca/EllipticCurve2.java:182:30:182:43 | Key | KeyType | Unknown | jca/EllipticCurve2.java:182:30:182:43 | jca/EllipticCurve2.java:182:30:182:43 | +| jca/EllipticCurve2.java:184:16:184:47 | VerifyOperation | KeyOperationSubtype | Verify | jca/EllipticCurve2.java:184:16:184:47 | jca/EllipticCurve2.java:184:16:184:47 | +| jca/EllipticCurve2.java:206:52:206:57 | KeyAgreementAlgorithm | Name | ECDH | jca/EllipticCurve2.java:206:52:206:57 | jca/EllipticCurve2.java:206:52:206:57 | +| jca/EllipticCurve2.java:206:52:206:57 | KeyAgreementAlgorithm | RawName | ECDH | jca/EllipticCurve2.java:206:52:206:57 | jca/EllipticCurve2.java:206:52:206:57 | +| jca/EllipticCurve2.java:207:17:207:37 | Key | KeyType | Unknown | jca/EllipticCurve2.java:207:17:207:37 | jca/EllipticCurve2.java:207:17:207:37 | +| jca/EllipticCurve2.java:208:20:208:41 | Key | KeyType | Unknown | jca/EllipticCurve2.java:208:20:208:41 | jca/EllipticCurve2.java:208:20:208:41 | +| jca/EllipticCurve2.java:213:58:213:66 | HashAlgorithm | DigestSize | 256 | jca/EllipticCurve2.java:213:58:213:66 | jca/EllipticCurve2.java:213:58:213:66 | +| jca/EllipticCurve2.java:213:58:213:66 | HashAlgorithm | Name | SHA2 | jca/EllipticCurve2.java:213:58:213:66 | jca/EllipticCurve2.java:213:58:213:66 | +| jca/EllipticCurve2.java:213:58:213:66 | HashAlgorithm | RawName | SHA-256 | jca/EllipticCurve2.java:213:58:213:66 | jca/EllipticCurve2.java:213:58:213:66 | +| jca/EllipticCurve2.java:219:44:219:62 | KeyOperationAlgorithm | Name | AES | jca/EllipticCurve2.java:219:44:219:62 | jca/EllipticCurve2.java:219:44:219:62 | +| jca/EllipticCurve2.java:219:44:219:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/EllipticCurve2.java:219:44:219:62 | jca/EllipticCurve2.java:219:44:219:62 | +| jca/EllipticCurve2.java:219:44:219:62 | KeyOperationAlgorithm | Structure | Block | jca/EllipticCurve2.java:219:44:219:62 | jca/EllipticCurve2.java:219:44:219:62 | +| jca/EllipticCurve2.java:219:44:219:62 | ModeOfOperation | Name | GCM | jca/EllipticCurve2.java:219:44:219:62 | jca/EllipticCurve2.java:219:44:219:62 | +| jca/EllipticCurve2.java:219:44:219:62 | ModeOfOperation | RawName | GCM | jca/EllipticCurve2.java:219:44:219:62 | jca/EllipticCurve2.java:219:44:219:62 | +| jca/EllipticCurve2.java:219:44:219:62 | PaddingAlgorithm | Name | UnknownPadding | jca/EllipticCurve2.java:219:44:219:62 | jca/EllipticCurve2.java:219:44:219:62 | +| jca/EllipticCurve2.java:219:44:219:62 | PaddingAlgorithm | RawName | NoPadding | jca/EllipticCurve2.java:219:44:219:62 | jca/EllipticCurve2.java:219:44:219:62 | +| jca/EllipticCurve2.java:221:9:221:40 | RandomNumberGeneration | Description | nextBytes | jca/EllipticCurve2.java:221:9:221:40 | jca/EllipticCurve2.java:221:9:221:40 | +| jca/EllipticCurve2.java:221:38:221:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/EllipticCurve2.java:221:38:221:39 | jca/EllipticCurve2.java:221:38:221:39 | +| jca/EllipticCurve2.java:223:42:223:47 | Key | KeyType | Unknown | jca/EllipticCurve2.java:223:42:223:47 | jca/EllipticCurve2.java:223:42:223:47 | +| jca/EllipticCurve2.java:224:29:224:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/EllipticCurve2.java:224:29:224:53 | jca/EllipticCurve2.java:224:29:224:53 | +| jca/EllipticCurve2.java:245:30:245:53 | Constant | Description | "Test message for ECDSA" | jca/EllipticCurve2.java:245:30:245:53 | jca/EllipticCurve2.java:245:30:245:53 | +| jca/EllipticCurve2.java:258:62:258:83 | Constant | Description | "Secret ECIES Message" | jca/EllipticCurve2.java:258:62:258:83 | jca/EllipticCurve2.java:258:62:258:83 | +| jca/Encryption1.java:60:56:60:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/Encryption1.java:61:21:61:23 | jca/Encryption1.java:61:21:61:23 | +| jca/Encryption1.java:60:56:60:60 | KeyOperationAlgorithm | Name | AES | jca/Encryption1.java:60:56:60:60 | jca/Encryption1.java:60:56:60:60 | +| jca/Encryption1.java:60:56:60:60 | KeyOperationAlgorithm | RawName | AES | jca/Encryption1.java:60:56:60:60 | jca/Encryption1.java:60:56:60:60 | +| jca/Encryption1.java:60:56:60:60 | KeyOperationAlgorithm | Structure | Block | jca/Encryption1.java:60:56:60:60 | jca/Encryption1.java:60:56:60:60 | +| jca/Encryption1.java:61:21:61:23 | Constant | Description | 256 | jca/Encryption1.java:61:21:61:23 | jca/Encryption1.java:61:21:61:23 | +| jca/Encryption1.java:62:25:62:44 | Key | KeyType | Symmetric | jca/Encryption1.java:62:25:62:44 | jca/Encryption1.java:62:25:62:44 | +| jca/Encryption1.java:63:44:63:62 | KeyOperationAlgorithm | Name | AES | jca/Encryption1.java:63:44:63:62 | jca/Encryption1.java:63:44:63:62 | +| jca/Encryption1.java:63:44:63:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/Encryption1.java:63:44:63:62 | jca/Encryption1.java:63:44:63:62 | +| jca/Encryption1.java:63:44:63:62 | KeyOperationAlgorithm | Structure | Block | jca/Encryption1.java:63:44:63:62 | jca/Encryption1.java:63:44:63:62 | +| jca/Encryption1.java:63:44:63:62 | ModeOfOperation | Name | GCM | jca/Encryption1.java:63:44:63:62 | jca/Encryption1.java:63:44:63:62 | +| jca/Encryption1.java:63:44:63:62 | ModeOfOperation | RawName | GCM | jca/Encryption1.java:63:44:63:62 | jca/Encryption1.java:63:44:63:62 | +| jca/Encryption1.java:63:44:63:62 | PaddingAlgorithm | Name | UnknownPadding | jca/Encryption1.java:63:44:63:62 | jca/Encryption1.java:63:44:63:62 | +| jca/Encryption1.java:63:44:63:62 | PaddingAlgorithm | RawName | NoPadding | jca/Encryption1.java:63:44:63:62 | jca/Encryption1.java:63:44:63:62 | +| jca/Encryption1.java:65:9:65:40 | RandomNumberGeneration | Description | nextBytes | jca/Encryption1.java:65:9:65:40 | jca/Encryption1.java:65:9:65:40 | +| jca/Encryption1.java:65:38:65:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/Encryption1.java:65:38:65:39 | jca/Encryption1.java:65:38:65:39 | +| jca/Encryption1.java:67:42:67:44 | Key | KeyType | Unknown | jca/Encryption1.java:67:42:67:44 | jca/Encryption1.java:67:42:67:44 | +| jca/Encryption1.java:68:32:68:74 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Encryption1.java:68:32:68:74 | jca/Encryption1.java:68:32:68:74 | +| jca/Encryption1.java:68:47:68:62 | Constant | Description | "Sensitive Data" | jca/Encryption1.java:68:47:68:62 | jca/Encryption1.java:68:47:68:62 | +| jca/Encryption1.java:83:56:83:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/Encryption1.java:84:21:84:23 | jca/Encryption1.java:84:21:84:23 | +| jca/Encryption1.java:83:56:83:60 | KeyOperationAlgorithm | Name | AES | jca/Encryption1.java:83:56:83:60 | jca/Encryption1.java:83:56:83:60 | +| jca/Encryption1.java:83:56:83:60 | KeyOperationAlgorithm | RawName | AES | jca/Encryption1.java:83:56:83:60 | jca/Encryption1.java:83:56:83:60 | +| jca/Encryption1.java:83:56:83:60 | KeyOperationAlgorithm | Structure | Block | jca/Encryption1.java:83:56:83:60 | jca/Encryption1.java:83:56:83:60 | +| jca/Encryption1.java:84:21:84:23 | Constant | Description | 256 | jca/Encryption1.java:84:21:84:23 | jca/Encryption1.java:84:21:84:23 | +| jca/Encryption1.java:85:25:85:44 | Key | KeyType | Symmetric | jca/Encryption1.java:85:25:85:44 | jca/Encryption1.java:85:25:85:44 | +| jca/Encryption1.java:88:44:88:62 | KeyOperationAlgorithm | Name | AES | jca/Encryption1.java:88:44:88:62 | jca/Encryption1.java:88:44:88:62 | +| jca/Encryption1.java:88:44:88:62 | KeyOperationAlgorithm | RawName | AES/ECB/NoPadding | jca/Encryption1.java:88:44:88:62 | jca/Encryption1.java:88:44:88:62 | +| jca/Encryption1.java:88:44:88:62 | KeyOperationAlgorithm | Structure | Block | jca/Encryption1.java:88:44:88:62 | jca/Encryption1.java:88:44:88:62 | +| jca/Encryption1.java:88:44:88:62 | ModeOfOperation | Name | ECB | jca/Encryption1.java:88:44:88:62 | jca/Encryption1.java:88:44:88:62 | +| jca/Encryption1.java:88:44:88:62 | ModeOfOperation | RawName | ECB | jca/Encryption1.java:88:44:88:62 | jca/Encryption1.java:88:44:88:62 | +| jca/Encryption1.java:88:44:88:62 | PaddingAlgorithm | Name | UnknownPadding | jca/Encryption1.java:88:44:88:62 | jca/Encryption1.java:88:44:88:62 | +| jca/Encryption1.java:88:44:88:62 | PaddingAlgorithm | RawName | NoPadding | jca/Encryption1.java:88:44:88:62 | jca/Encryption1.java:88:44:88:62 | +| jca/Encryption1.java:89:42:89:44 | Key | KeyType | Unknown | jca/Encryption1.java:89:42:89:44 | jca/Encryption1.java:89:42:89:44 | +| jca/Encryption1.java:90:32:90:74 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Encryption1.java:90:32:90:74 | jca/Encryption1.java:90:32:90:74 | +| jca/Encryption1.java:90:47:90:62 | Constant | Description | "Sensitive Data" | jca/Encryption1.java:90:47:90:62 | jca/Encryption1.java:90:47:90:62 | +| jca/Encryption1.java:104:35:104:53 | Parameter | Description | publicKey | jca/Encryption1.java:104:35:104:53 | jca/Encryption1.java:104:35:104:53 | +| jca/Encryption1.java:104:56:104:66 | Parameter | Description | data | jca/Encryption1.java:104:56:104:66 | jca/Encryption1.java:104:56:104:66 | +| jca/Encryption1.java:105:44:105:82 | HashAlgorithm | DigestSize | 256 | jca/Encryption1.java:105:44:105:82 | jca/Encryption1.java:105:44:105:82 | +| jca/Encryption1.java:105:44:105:82 | HashAlgorithm | Name | SHA2 | jca/Encryption1.java:105:44:105:82 | jca/Encryption1.java:105:44:105:82 | +| jca/Encryption1.java:105:44:105:82 | HashAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:105:44:105:82 | jca/Encryption1.java:105:44:105:82 | +| jca/Encryption1.java:105:44:105:82 | KeyOperationAlgorithm | Name | RSA | jca/Encryption1.java:105:44:105:82 | jca/Encryption1.java:105:44:105:82 | +| jca/Encryption1.java:105:44:105:82 | KeyOperationAlgorithm | RawName | RSA/ECB/OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:105:44:105:82 | jca/Encryption1.java:105:44:105:82 | +| jca/Encryption1.java:105:44:105:82 | ModeOfOperation | Name | ECB | jca/Encryption1.java:105:44:105:82 | jca/Encryption1.java:105:44:105:82 | +| jca/Encryption1.java:105:44:105:82 | ModeOfOperation | RawName | ECB | jca/Encryption1.java:105:44:105:82 | jca/Encryption1.java:105:44:105:82 | +| jca/Encryption1.java:105:44:105:82 | PaddingAlgorithm | Name | OAEP | jca/Encryption1.java:105:44:105:82 | jca/Encryption1.java:105:44:105:82 | +| jca/Encryption1.java:105:44:105:82 | PaddingAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:105:44:105:82 | jca/Encryption1.java:105:44:105:82 | +| jca/Encryption1.java:106:42:106:50 | Key | KeyType | Unknown | jca/Encryption1.java:106:42:106:50 | jca/Encryption1.java:106:42:106:50 | +| jca/Encryption1.java:107:32:107:62 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Encryption1.java:107:32:107:62 | jca/Encryption1.java:107:32:107:62 | +| jca/Encryption1.java:119:35:119:55 | Parameter | Description | privateKey | jca/Encryption1.java:119:35:119:55 | jca/Encryption1.java:119:35:119:55 | +| jca/Encryption1.java:119:58:119:77 | Parameter | Description | encryptedData | jca/Encryption1.java:119:58:119:77 | jca/Encryption1.java:119:58:119:77 | +| jca/Encryption1.java:120:44:120:82 | HashAlgorithm | DigestSize | 256 | jca/Encryption1.java:120:44:120:82 | jca/Encryption1.java:120:44:120:82 | +| jca/Encryption1.java:120:44:120:82 | HashAlgorithm | Name | SHA2 | jca/Encryption1.java:120:44:120:82 | jca/Encryption1.java:120:44:120:82 | +| jca/Encryption1.java:120:44:120:82 | HashAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:120:44:120:82 | jca/Encryption1.java:120:44:120:82 | +| jca/Encryption1.java:120:44:120:82 | KeyOperationAlgorithm | Name | RSA | jca/Encryption1.java:120:44:120:82 | jca/Encryption1.java:120:44:120:82 | +| jca/Encryption1.java:120:44:120:82 | KeyOperationAlgorithm | RawName | RSA/ECB/OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:120:44:120:82 | jca/Encryption1.java:120:44:120:82 | +| jca/Encryption1.java:120:44:120:82 | ModeOfOperation | Name | ECB | jca/Encryption1.java:120:44:120:82 | jca/Encryption1.java:120:44:120:82 | +| jca/Encryption1.java:120:44:120:82 | ModeOfOperation | RawName | ECB | jca/Encryption1.java:120:44:120:82 | jca/Encryption1.java:120:44:120:82 | +| jca/Encryption1.java:120:44:120:82 | PaddingAlgorithm | Name | OAEP | jca/Encryption1.java:120:44:120:82 | jca/Encryption1.java:120:44:120:82 | +| jca/Encryption1.java:120:44:120:82 | PaddingAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:120:44:120:82 | jca/Encryption1.java:120:44:120:82 | +| jca/Encryption1.java:121:42:121:51 | Key | KeyType | Unknown | jca/Encryption1.java:121:42:121:51 | jca/Encryption1.java:121:42:121:51 | +| jca/Encryption1.java:122:32:122:60 | DecryptOperation | KeyOperationSubtype | Decrypt | jca/Encryption1.java:122:32:122:60 | jca/Encryption1.java:122:32:122:60 | +| jca/Encryption1.java:136:34:136:55 | Parameter | Description | rsaPublicKey | jca/Encryption1.java:136:34:136:55 | jca/Encryption1.java:136:34:136:55 | +| jca/Encryption1.java:137:56:137:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/Encryption1.java:138:21:138:23 | jca/Encryption1.java:138:21:138:23 | +| jca/Encryption1.java:137:56:137:60 | KeyOperationAlgorithm | Name | AES | jca/Encryption1.java:137:56:137:60 | jca/Encryption1.java:137:56:137:60 | +| jca/Encryption1.java:137:56:137:60 | KeyOperationAlgorithm | RawName | AES | jca/Encryption1.java:137:56:137:60 | jca/Encryption1.java:137:56:137:60 | +| jca/Encryption1.java:137:56:137:60 | KeyOperationAlgorithm | Structure | Block | jca/Encryption1.java:137:56:137:60 | jca/Encryption1.java:137:56:137:60 | +| jca/Encryption1.java:138:21:138:23 | Constant | Description | 256 | jca/Encryption1.java:138:21:138:23 | jca/Encryption1.java:138:21:138:23 | +| jca/Encryption1.java:139:28:139:47 | Key | KeyType | Symmetric | jca/Encryption1.java:139:28:139:47 | jca/Encryption1.java:139:28:139:47 | +| jca/Encryption1.java:141:47:141:85 | HashAlgorithm | DigestSize | 256 | jca/Encryption1.java:141:47:141:85 | jca/Encryption1.java:141:47:141:85 | +| jca/Encryption1.java:141:47:141:85 | HashAlgorithm | Name | SHA2 | jca/Encryption1.java:141:47:141:85 | jca/Encryption1.java:141:47:141:85 | +| jca/Encryption1.java:141:47:141:85 | HashAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:141:47:141:85 | jca/Encryption1.java:141:47:141:85 | +| jca/Encryption1.java:141:47:141:85 | KeyOperationAlgorithm | Name | RSA | jca/Encryption1.java:141:47:141:85 | jca/Encryption1.java:141:47:141:85 | +| jca/Encryption1.java:141:47:141:85 | KeyOperationAlgorithm | RawName | RSA/ECB/OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:141:47:141:85 | jca/Encryption1.java:141:47:141:85 | +| jca/Encryption1.java:141:47:141:85 | ModeOfOperation | Name | ECB | jca/Encryption1.java:141:47:141:85 | jca/Encryption1.java:141:47:141:85 | +| jca/Encryption1.java:141:47:141:85 | ModeOfOperation | RawName | ECB | jca/Encryption1.java:141:47:141:85 | jca/Encryption1.java:141:47:141:85 | +| jca/Encryption1.java:141:47:141:85 | PaddingAlgorithm | Name | OAEP | jca/Encryption1.java:141:47:141:85 | jca/Encryption1.java:141:47:141:85 | +| jca/Encryption1.java:141:47:141:85 | PaddingAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:141:47:141:85 | jca/Encryption1.java:141:47:141:85 | +| jca/Encryption1.java:142:45:142:56 | Key | KeyType | Unknown | jca/Encryption1.java:142:45:142:56 | jca/Encryption1.java:142:45:142:56 | +| jca/Encryption1.java:143:34:143:71 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Encryption1.java:143:34:143:71 | jca/Encryption1.java:143:34:143:71 | +| jca/Encryption1.java:159:34:159:55 | Parameter | Description | rsaPublicKey | jca/Encryption1.java:159:34:159:55 | jca/Encryption1.java:159:34:159:55 | +| jca/Encryption1.java:159:58:159:68 | Parameter | Description | data | jca/Encryption1.java:159:58:159:68 | jca/Encryption1.java:159:58:159:68 | +| jca/Encryption1.java:161:56:161:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/Encryption1.java:162:21:162:23 | jca/Encryption1.java:162:21:162:23 | +| jca/Encryption1.java:161:56:161:60 | KeyOperationAlgorithm | Name | AES | jca/Encryption1.java:161:56:161:60 | jca/Encryption1.java:161:56:161:60 | +| jca/Encryption1.java:161:56:161:60 | KeyOperationAlgorithm | RawName | AES | jca/Encryption1.java:161:56:161:60 | jca/Encryption1.java:161:56:161:60 | +| jca/Encryption1.java:161:56:161:60 | KeyOperationAlgorithm | Structure | Block | jca/Encryption1.java:161:56:161:60 | jca/Encryption1.java:161:56:161:60 | +| jca/Encryption1.java:162:21:162:23 | Constant | Description | 256 | jca/Encryption1.java:162:21:162:23 | jca/Encryption1.java:162:21:162:23 | +| jca/Encryption1.java:163:28:163:47 | Key | KeyType | Symmetric | jca/Encryption1.java:163:28:163:47 | jca/Encryption1.java:163:28:163:47 | +| jca/Encryption1.java:166:47:166:85 | HashAlgorithm | DigestSize | 256 | jca/Encryption1.java:166:47:166:85 | jca/Encryption1.java:166:47:166:85 | +| jca/Encryption1.java:166:47:166:85 | HashAlgorithm | Name | SHA2 | jca/Encryption1.java:166:47:166:85 | jca/Encryption1.java:166:47:166:85 | +| jca/Encryption1.java:166:47:166:85 | HashAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:166:47:166:85 | jca/Encryption1.java:166:47:166:85 | +| jca/Encryption1.java:166:47:166:85 | KeyOperationAlgorithm | Name | RSA | jca/Encryption1.java:166:47:166:85 | jca/Encryption1.java:166:47:166:85 | +| jca/Encryption1.java:166:47:166:85 | KeyOperationAlgorithm | RawName | RSA/ECB/OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:166:47:166:85 | jca/Encryption1.java:166:47:166:85 | +| jca/Encryption1.java:166:47:166:85 | ModeOfOperation | Name | ECB | jca/Encryption1.java:166:47:166:85 | jca/Encryption1.java:166:47:166:85 | +| jca/Encryption1.java:166:47:166:85 | ModeOfOperation | RawName | ECB | jca/Encryption1.java:166:47:166:85 | jca/Encryption1.java:166:47:166:85 | +| jca/Encryption1.java:166:47:166:85 | PaddingAlgorithm | Name | OAEP | jca/Encryption1.java:166:47:166:85 | jca/Encryption1.java:166:47:166:85 | +| jca/Encryption1.java:166:47:166:85 | PaddingAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/Encryption1.java:166:47:166:85 | jca/Encryption1.java:166:47:166:85 | +| jca/Encryption1.java:167:45:167:56 | Key | KeyType | Unknown | jca/Encryption1.java:167:45:167:56 | jca/Encryption1.java:167:45:167:56 | +| jca/Encryption1.java:168:34:168:71 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Encryption1.java:168:34:168:71 | jca/Encryption1.java:168:34:168:71 | +| jca/Encryption1.java:171:47:171:65 | KeyOperationAlgorithm | Name | AES | jca/Encryption1.java:171:47:171:65 | jca/Encryption1.java:171:47:171:65 | +| jca/Encryption1.java:171:47:171:65 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/Encryption1.java:171:47:171:65 | jca/Encryption1.java:171:47:171:65 | +| jca/Encryption1.java:171:47:171:65 | KeyOperationAlgorithm | Structure | Block | jca/Encryption1.java:171:47:171:65 | jca/Encryption1.java:171:47:171:65 | +| jca/Encryption1.java:171:47:171:65 | ModeOfOperation | Name | GCM | jca/Encryption1.java:171:47:171:65 | jca/Encryption1.java:171:47:171:65 | +| jca/Encryption1.java:171:47:171:65 | ModeOfOperation | RawName | GCM | jca/Encryption1.java:171:47:171:65 | jca/Encryption1.java:171:47:171:65 | +| jca/Encryption1.java:171:47:171:65 | PaddingAlgorithm | Name | UnknownPadding | jca/Encryption1.java:171:47:171:65 | jca/Encryption1.java:171:47:171:65 | +| jca/Encryption1.java:171:47:171:65 | PaddingAlgorithm | RawName | NoPadding | jca/Encryption1.java:171:47:171:65 | jca/Encryption1.java:171:47:171:65 | +| jca/Encryption1.java:173:9:173:40 | RandomNumberGeneration | Description | nextBytes | jca/Encryption1.java:173:9:173:40 | jca/Encryption1.java:173:9:173:40 | +| jca/Encryption1.java:173:38:173:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/Encryption1.java:173:38:173:39 | jca/Encryption1.java:173:38:173:39 | +| jca/Encryption1.java:175:45:175:50 | Key | KeyType | Unknown | jca/Encryption1.java:175:45:175:50 | jca/Encryption1.java:175:45:175:50 | +| jca/Encryption1.java:176:32:176:65 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Encryption1.java:176:32:176:65 | jca/Encryption1.java:176:32:176:65 | +| jca/Encryption2.java:55:60:55:70 | EllipticCurve | KeySize | 256 | jca/Encryption2.java:55:60:55:70 | jca/Encryption2.java:55:60:55:70 | +| jca/Encryption2.java:55:60:55:70 | EllipticCurve | Name | secp256r1 | jca/Encryption2.java:55:60:55:70 | jca/Encryption2.java:55:60:55:70 | +| jca/Encryption2.java:55:60:55:70 | EllipticCurve | ParsedName | secp256r1 | jca/Encryption2.java:55:60:55:70 | jca/Encryption2.java:55:60:55:70 | +| jca/Encryption2.java:55:60:55:70 | EllipticCurve | RawName | secp256r1 | jca/Encryption2.java:55:60:55:70 | jca/Encryption2.java:55:60:55:70 | +| jca/Encryption2.java:56:16:56:49 | Key | KeyType | Asymmetric | jca/Encryption2.java:56:16:56:49 | jca/Encryption2.java:56:16:56:49 | +| jca/Encryption2.java:71:62:71:67 | KeyAgreementAlgorithm | Name | ECDH | jca/Encryption2.java:71:62:71:67 | jca/Encryption2.java:71:62:71:67 | +| jca/Encryption2.java:71:62:71:67 | KeyAgreementAlgorithm | RawName | ECDH | jca/Encryption2.java:71:62:71:67 | jca/Encryption2.java:71:62:71:67 | +| jca/Encryption2.java:72:27:72:36 | Key | KeyType | Unknown | jca/Encryption2.java:72:27:72:36 | jca/Encryption2.java:72:27:72:36 | +| jca/Encryption2.java:73:30:73:38 | Key | KeyType | Unknown | jca/Encryption2.java:73:30:73:38 | jca/Encryption2.java:73:30:73:38 | +| jca/Encryption2.java:90:38:90:65 | Parameter | Description | recipientPublicKey | jca/Encryption2.java:90:38:90:65 | jca/Encryption2.java:90:38:90:65 | +| jca/Encryption2.java:90:68:90:78 | Parameter | Description | data | jca/Encryption2.java:90:68:90:78 | jca/Encryption2.java:90:68:90:78 | +| jca/Encryption2.java:99:58:99:66 | HashAlgorithm | DigestSize | 256 | jca/Encryption2.java:99:58:99:66 | jca/Encryption2.java:99:58:99:66 | +| jca/Encryption2.java:99:58:99:66 | HashAlgorithm | Name | SHA2 | jca/Encryption2.java:99:58:99:66 | jca/Encryption2.java:99:58:99:66 | +| jca/Encryption2.java:99:58:99:66 | HashAlgorithm | RawName | SHA-256 | jca/Encryption2.java:99:58:99:66 | jca/Encryption2.java:99:58:99:66 | +| jca/Encryption2.java:105:47:105:65 | KeyOperationAlgorithm | Name | AES | jca/Encryption2.java:105:47:105:65 | jca/Encryption2.java:105:47:105:65 | +| jca/Encryption2.java:105:47:105:65 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/Encryption2.java:105:47:105:65 | jca/Encryption2.java:105:47:105:65 | +| jca/Encryption2.java:105:47:105:65 | KeyOperationAlgorithm | Structure | Block | jca/Encryption2.java:105:47:105:65 | jca/Encryption2.java:105:47:105:65 | +| jca/Encryption2.java:105:47:105:65 | ModeOfOperation | Name | GCM | jca/Encryption2.java:105:47:105:65 | jca/Encryption2.java:105:47:105:65 | +| jca/Encryption2.java:105:47:105:65 | ModeOfOperation | RawName | GCM | jca/Encryption2.java:105:47:105:65 | jca/Encryption2.java:105:47:105:65 | +| jca/Encryption2.java:105:47:105:65 | PaddingAlgorithm | Name | UnknownPadding | jca/Encryption2.java:105:47:105:65 | jca/Encryption2.java:105:47:105:65 | +| jca/Encryption2.java:105:47:105:65 | PaddingAlgorithm | RawName | NoPadding | jca/Encryption2.java:105:47:105:65 | jca/Encryption2.java:105:47:105:65 | +| jca/Encryption2.java:107:9:107:40 | RandomNumberGeneration | Description | nextBytes | jca/Encryption2.java:107:9:107:40 | jca/Encryption2.java:107:9:107:40 | +| jca/Encryption2.java:107:38:107:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/Encryption2.java:107:38:107:39 | jca/Encryption2.java:107:38:107:39 | +| jca/Encryption2.java:109:45:109:50 | Key | KeyType | Unknown | jca/Encryption2.java:109:45:109:50 | jca/Encryption2.java:109:45:109:50 | +| jca/Encryption2.java:110:32:110:65 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Encryption2.java:110:32:110:65 | jca/Encryption2.java:110:32:110:65 | +| jca/Encryption2.java:132:45:132:65 | Parameter | Description | ecPublicKey | jca/Encryption2.java:132:45:132:65 | jca/Encryption2.java:132:45:132:65 | +| jca/Encryption2.java:132:68:132:88 | Parameter | Description | pqSharedSecret | jca/Encryption2.java:132:68:132:88 | jca/Encryption2.java:132:68:132:88 | +| jca/Encryption2.java:145:47:145:65 | KeyOperationAlgorithm | Name | AES | jca/Encryption2.java:145:47:145:65 | jca/Encryption2.java:145:47:145:65 | +| jca/Encryption2.java:145:47:145:65 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/Encryption2.java:145:47:145:65 | jca/Encryption2.java:145:47:145:65 | +| jca/Encryption2.java:145:47:145:65 | KeyOperationAlgorithm | Structure | Block | jca/Encryption2.java:145:47:145:65 | jca/Encryption2.java:145:47:145:65 | +| jca/Encryption2.java:145:47:145:65 | ModeOfOperation | Name | GCM | jca/Encryption2.java:145:47:145:65 | jca/Encryption2.java:145:47:145:65 | +| jca/Encryption2.java:145:47:145:65 | ModeOfOperation | RawName | GCM | jca/Encryption2.java:145:47:145:65 | jca/Encryption2.java:145:47:145:65 | +| jca/Encryption2.java:145:47:145:65 | PaddingAlgorithm | Name | UnknownPadding | jca/Encryption2.java:145:47:145:65 | jca/Encryption2.java:145:47:145:65 | +| jca/Encryption2.java:145:47:145:65 | PaddingAlgorithm | RawName | NoPadding | jca/Encryption2.java:145:47:145:65 | jca/Encryption2.java:145:47:145:65 | +| jca/Encryption2.java:147:9:147:40 | RandomNumberGeneration | Description | nextBytes | jca/Encryption2.java:147:9:147:40 | jca/Encryption2.java:147:9:147:40 | +| jca/Encryption2.java:147:38:147:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/Encryption2.java:147:38:147:39 | jca/Encryption2.java:147:38:147:39 | +| jca/Encryption2.java:149:45:149:50 | Key | KeyType | Unknown | jca/Encryption2.java:149:45:149:50 | jca/Encryption2.java:149:45:149:50 | +| jca/Encryption2.java:150:32:150:98 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Encryption2.java:150:32:150:98 | jca/Encryption2.java:150:32:150:98 | +| jca/Encryption2.java:150:50:150:86 | Constant | Description | "Post-Quantum Hybrid Encryption Data" | jca/Encryption2.java:150:50:150:86 | jca/Encryption2.java:150:50:150:86 | +| jca/Encryption2.java:173:36:173:47 | KeyOperationAlgorithm | Name | HMAC | jca/Encryption2.java:173:36:173:47 | jca/Encryption2.java:173:36:173:47 | +| jca/Encryption2.java:173:36:173:47 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/Encryption2.java:173:36:173:47 | jca/Encryption2.java:173:36:173:47 | +| jca/Encryption2.java:175:19:175:27 | Key | KeyType | Unknown | jca/Encryption2.java:175:19:175:27 | jca/Encryption2.java:175:19:175:27 | +| jca/Encryption2.java:176:31:176:52 | MACOperation | KeyOperationSubtype | Mac | jca/Encryption2.java:176:31:176:52 | jca/Encryption2.java:176:31:176:52 | +| jca/Hash.java:75:58:75:66 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:75:58:75:66 | jca/Hash.java:75:58:75:66 | +| jca/Hash.java:75:58:75:66 | HashAlgorithm | Name | SHA2 | jca/Hash.java:75:58:75:66 | jca/Hash.java:75:58:75:66 | +| jca/Hash.java:75:58:75:66 | HashAlgorithm | RawName | SHA-256 | jca/Hash.java:75:58:75:66 | jca/Hash.java:75:58:75:66 | +| jca/Hash.java:76:37:76:54 | Constant | Description | "Simple Test Data" | jca/Hash.java:76:37:76:54 | jca/Hash.java:76:37:76:54 | +| jca/Hash.java:88:61:88:65 | HashAlgorithm | DigestSize | 128 | jca/Hash.java:88:61:88:65 | jca/Hash.java:88:61:88:65 | +| jca/Hash.java:88:61:88:65 | HashAlgorithm | Name | MD5 | jca/Hash.java:88:61:88:65 | jca/Hash.java:88:61:88:65 | +| jca/Hash.java:88:61:88:65 | HashAlgorithm | RawName | MD5 | jca/Hash.java:88:61:88:65 | jca/Hash.java:88:61:88:65 | +| jca/Hash.java:89:40:89:58 | Constant | Description | "Weak Hash Example" | jca/Hash.java:89:40:89:58 | jca/Hash.java:89:40:89:58 | +| jca/Hash.java:133:29:133:40 | Parameter | Description | input | jca/Hash.java:133:29:133:40 | jca/Hash.java:133:29:133:40 | +| jca/Hash.java:133:43:133:63 | Parameter | Description | privateKey | jca/Hash.java:133:43:133:63 | jca/Hash.java:133:43:133:63 | +| jca/Hash.java:134:53:134:67 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:134:53:134:67 | jca/Hash.java:134:53:134:67 | +| jca/Hash.java:134:53:134:67 | HashAlgorithm | Name | SHA2 | jca/Hash.java:134:53:134:67 | jca/Hash.java:134:53:134:67 | +| jca/Hash.java:134:53:134:67 | HashAlgorithm | RawName | SHA256withRSA | jca/Hash.java:134:53:134:67 | jca/Hash.java:134:53:134:67 | +| jca/Hash.java:134:53:134:67 | KeyOperationAlgorithm | Name | RSA | jca/Hash.java:134:53:134:67 | jca/Hash.java:134:53:134:67 | +| jca/Hash.java:134:53:134:67 | KeyOperationAlgorithm | RawName | SHA256withRSA | jca/Hash.java:134:53:134:67 | jca/Hash.java:134:53:134:67 | +| jca/Hash.java:135:28:135:37 | Key | KeyType | Unknown | jca/Hash.java:135:28:135:37 | jca/Hash.java:135:28:135:37 | +| jca/Hash.java:137:29:137:44 | SignOperation | KeyOperationSubtype | Sign | jca/Hash.java:137:29:137:44 | jca/Hash.java:137:29:137:44 | +| jca/Hash.java:154:40:154:51 | Parameter | Description | input | jca/Hash.java:154:40:154:51 | jca/Hash.java:154:40:154:51 | +| jca/Hash.java:154:54:154:70 | Parameter | Description | signedHash | jca/Hash.java:154:54:154:70 | jca/Hash.java:154:54:154:70 | +| jca/Hash.java:154:73:154:91 | Parameter | Description | publicKey | jca/Hash.java:154:73:154:91 | jca/Hash.java:154:73:154:91 | +| jca/Hash.java:155:53:155:67 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:155:53:155:67 | jca/Hash.java:155:53:155:67 | +| jca/Hash.java:155:53:155:67 | HashAlgorithm | Name | SHA2 | jca/Hash.java:155:53:155:67 | jca/Hash.java:155:53:155:67 | +| jca/Hash.java:155:53:155:67 | HashAlgorithm | RawName | SHA256withRSA | jca/Hash.java:155:53:155:67 | jca/Hash.java:155:53:155:67 | +| jca/Hash.java:155:53:155:67 | KeyOperationAlgorithm | Name | RSA | jca/Hash.java:155:53:155:67 | jca/Hash.java:155:53:155:67 | +| jca/Hash.java:155:53:155:67 | KeyOperationAlgorithm | RawName | SHA256withRSA | jca/Hash.java:155:53:155:67 | jca/Hash.java:155:53:155:67 | +| jca/Hash.java:156:30:156:38 | Key | KeyType | Unknown | jca/Hash.java:156:30:156:38 | jca/Hash.java:156:30:156:38 | +| jca/Hash.java:158:16:158:43 | VerifyOperation | KeyOperationSubtype | Verify | jca/Hash.java:158:16:158:43 | jca/Hash.java:158:16:158:43 | +| jca/Hash.java:172:43:172:53 | Parameter | Description | data | jca/Hash.java:172:43:172:53 | jca/Hash.java:172:43:172:53 | +| jca/Hash.java:173:58:173:66 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:173:58:173:66 | jca/Hash.java:173:58:173:66 | +| jca/Hash.java:173:58:173:66 | HashAlgorithm | Name | SHA2 | jca/Hash.java:173:58:173:66 | jca/Hash.java:173:58:173:66 | +| jca/Hash.java:173:58:173:66 | HashAlgorithm | RawName | SHA-256 | jca/Hash.java:173:58:173:66 | jca/Hash.java:173:58:173:66 | +| jca/Hash.java:190:43:190:54 | Parameter | Description | input | jca/Hash.java:190:43:190:54 | jca/Hash.java:190:43:190:54 | +| jca/Hash.java:191:32:191:38 | HashAlgorithm | DigestSize | 160 | jca/Hash.java:191:32:191:38 | jca/Hash.java:191:32:191:38 | +| jca/Hash.java:191:32:191:38 | HashAlgorithm | Name | SHA1 | jca/Hash.java:191:32:191:38 | jca/Hash.java:191:32:191:38 | +| jca/Hash.java:191:32:191:38 | HashAlgorithm | RawName | SHA-1 | jca/Hash.java:191:32:191:38 | jca/Hash.java:191:32:191:38 | +| jca/Hash.java:191:41:191:49 | HashAlgorithm | DigestSize | | file://:0:0:0:0 | file://:0:0:0:0 | +| jca/Hash.java:191:41:191:49 | HashAlgorithm | RawName | SHA-224 | jca/Hash.java:191:41:191:49 | jca/Hash.java:191:41:191:49 | +| jca/Hash.java:191:52:191:60 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:191:52:191:60 | jca/Hash.java:191:52:191:60 | +| jca/Hash.java:191:52:191:60 | HashAlgorithm | Name | SHA2 | jca/Hash.java:191:52:191:60 | jca/Hash.java:191:52:191:60 | +| jca/Hash.java:191:52:191:60 | HashAlgorithm | RawName | SHA-256 | jca/Hash.java:191:52:191:60 | jca/Hash.java:191:52:191:60 | +| jca/Hash.java:191:63:191:71 | HashAlgorithm | DigestSize | 384 | jca/Hash.java:191:63:191:71 | jca/Hash.java:191:63:191:71 | +| jca/Hash.java:191:63:191:71 | HashAlgorithm | Name | SHA2 | jca/Hash.java:191:63:191:71 | jca/Hash.java:191:63:191:71 | +| jca/Hash.java:191:63:191:71 | HashAlgorithm | RawName | SHA-384 | jca/Hash.java:191:63:191:71 | jca/Hash.java:191:63:191:71 | +| jca/Hash.java:191:74:191:82 | HashAlgorithm | DigestSize | 512 | jca/Hash.java:191:74:191:82 | jca/Hash.java:191:74:191:82 | +| jca/Hash.java:191:74:191:82 | HashAlgorithm | Name | SHA2 | jca/Hash.java:191:74:191:82 | jca/Hash.java:191:74:191:82 | +| jca/Hash.java:191:74:191:82 | HashAlgorithm | RawName | SHA-512 | jca/Hash.java:191:74:191:82 | jca/Hash.java:191:74:191:82 | +| jca/Hash.java:191:85:191:94 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:191:85:191:94 | jca/Hash.java:191:85:191:94 | +| jca/Hash.java:191:85:191:94 | HashAlgorithm | Name | SHA3 | jca/Hash.java:191:85:191:94 | jca/Hash.java:191:85:191:94 | +| jca/Hash.java:191:85:191:94 | HashAlgorithm | RawName | SHA3-256 | jca/Hash.java:191:85:191:94 | jca/Hash.java:191:85:191:94 | +| jca/Hash.java:191:97:191:106 | HashAlgorithm | DigestSize | 512 | jca/Hash.java:191:97:191:106 | jca/Hash.java:191:97:191:106 | +| jca/Hash.java:191:97:191:106 | HashAlgorithm | Name | SHA3 | jca/Hash.java:191:97:191:106 | jca/Hash.java:191:97:191:106 | +| jca/Hash.java:191:97:191:106 | HashAlgorithm | RawName | SHA3-512 | jca/Hash.java:191:97:191:106 | jca/Hash.java:191:97:191:106 | +| jca/Hash.java:192:13:192:25 | HashAlgorithm | DigestSize | | file://:0:0:0:0 | file://:0:0:0:0 | +| jca/Hash.java:192:13:192:25 | HashAlgorithm | RawName | BLAKE2B-512 | jca/Hash.java:192:13:192:25 | jca/Hash.java:192:13:192:25 | +| jca/Hash.java:192:28:192:40 | HashAlgorithm | DigestSize | | file://:0:0:0:0 | file://:0:0:0:0 | +| jca/Hash.java:192:28:192:40 | HashAlgorithm | RawName | BLAKE2S-256 | jca/Hash.java:192:28:192:40 | jca/Hash.java:192:28:192:40 | +| jca/Hash.java:192:43:192:47 | HashAlgorithm | DigestSize | 128 | jca/Hash.java:192:43:192:47 | jca/Hash.java:192:43:192:47 | +| jca/Hash.java:192:43:192:47 | HashAlgorithm | Name | MD5 | jca/Hash.java:192:43:192:47 | jca/Hash.java:192:43:192:47 | +| jca/Hash.java:192:43:192:47 | HashAlgorithm | RawName | MD5 | jca/Hash.java:192:43:192:47 | jca/Hash.java:192:43:192:47 | +| jca/Hash.java:211:43:211:54 | Parameter | Description | input | jca/Hash.java:211:43:211:54 | jca/Hash.java:211:43:211:54 | +| jca/Hash.java:211:57:211:66 | Parameter | Description | key | jca/Hash.java:211:57:211:66 | jca/Hash.java:211:57:211:66 | +| jca/Hash.java:212:32:212:41 | KeyOperationAlgorithm | Name | HMAC | jca/Hash.java:212:32:212:41 | jca/Hash.java:212:32:212:41 | +| jca/Hash.java:212:32:212:41 | KeyOperationAlgorithm | RawName | HmacSHA1 | jca/Hash.java:212:32:212:41 | jca/Hash.java:212:32:212:41 | +| jca/Hash.java:212:44:212:55 | KeyOperationAlgorithm | Name | HMAC | jca/Hash.java:212:44:212:55 | jca/Hash.java:212:44:212:55 | +| jca/Hash.java:212:44:212:55 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/Hash.java:212:44:212:55 | jca/Hash.java:212:44:212:55 | +| jca/Hash.java:212:58:212:69 | KeyOperationAlgorithm | Name | HMAC | jca/Hash.java:212:58:212:69 | jca/Hash.java:212:58:212:69 | +| jca/Hash.java:212:58:212:69 | KeyOperationAlgorithm | RawName | HmacSHA384 | jca/Hash.java:212:58:212:69 | jca/Hash.java:212:58:212:69 | +| jca/Hash.java:212:72:212:83 | KeyOperationAlgorithm | Name | HMAC | jca/Hash.java:212:72:212:83 | jca/Hash.java:212:72:212:83 | +| jca/Hash.java:212:72:212:83 | KeyOperationAlgorithm | RawName | HmacSHA512 | jca/Hash.java:212:72:212:83 | jca/Hash.java:212:72:212:83 | +| jca/Hash.java:212:86:212:99 | KeyOperationAlgorithm | Name | HMAC | jca/Hash.java:212:86:212:99 | jca/Hash.java:212:86:212:99 | +| jca/Hash.java:212:86:212:99 | KeyOperationAlgorithm | RawName | HmacSHA3-256 | jca/Hash.java:212:86:212:99 | jca/Hash.java:212:86:212:99 | +| jca/Hash.java:212:102:212:115 | KeyOperationAlgorithm | Name | HMAC | jca/Hash.java:212:102:212:115 | jca/Hash.java:212:102:212:115 | +| jca/Hash.java:212:102:212:115 | KeyOperationAlgorithm | RawName | HmacSHA3-512 | jca/Hash.java:212:102:212:115 | jca/Hash.java:212:102:212:115 | +| jca/Hash.java:216:22:216:30 | Key | KeyType | Unknown | jca/Hash.java:216:22:216:30 | jca/Hash.java:216:22:216:30 | +| jca/Hash.java:217:27:217:55 | MACOperation | KeyOperationSubtype | Mac | jca/Hash.java:217:27:217:55 | jca/Hash.java:217:27:217:55 | +| jca/Hash.java:232:40:232:54 | Parameter | Description | password | jca/Hash.java:232:40:232:54 | jca/Hash.java:232:40:232:54 | +| jca/Hash.java:235:72:235:76 | Constant | Description | 10000 | jca/Hash.java:235:72:235:76 | jca/Hash.java:235:72:235:76 | +| jca/Hash.java:235:79:235:81 | Constant | Description | 256 | jca/Hash.java:235:79:235:81 | jca/Hash.java:235:79:235:81 | +| jca/Hash.java:236:65:236:86 | HMACAlgorithm | Name | HMAC | jca/Hash.java:236:65:236:86 | jca/Hash.java:236:65:236:86 | +| jca/Hash.java:236:65:236:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/Hash.java:236:65:236:86 | jca/Hash.java:236:65:236:86 | +| jca/Hash.java:236:65:236:86 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:236:65:236:86 | jca/Hash.java:236:65:236:86 | +| jca/Hash.java:236:65:236:86 | HashAlgorithm | Name | SHA2 | jca/Hash.java:236:65:236:86 | jca/Hash.java:236:65:236:86 | +| jca/Hash.java:236:65:236:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/Hash.java:236:65:236:86 | jca/Hash.java:236:65:236:86 | +| jca/Hash.java:236:65:236:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/Hash.java:236:65:236:86 | jca/Hash.java:236:65:236:86 | +| jca/Hash.java:236:65:236:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/Hash.java:236:65:236:86 | jca/Hash.java:236:65:236:86 | +| jca/Hash.java:237:23:237:50 | Key | KeyType | Symmetric | jca/Hash.java:237:23:237:50 | jca/Hash.java:237:23:237:50 | +| jca/Hash.java:237:23:237:50 | KeyDerivation | Iterations | Constant:10000 | jca/Hash.java:235:72:235:76 | jca/Hash.java:235:72:235:76 | +| jca/Hash.java:237:23:237:50 | KeyDerivation | KeySize | Constant:256 | jca/Hash.java:235:79:235:81 | jca/Hash.java:235:79:235:81 | +| jca/Hash.java:252:37:252:58 | Constant | Description | "Config-based Hashing" | jca/Hash.java:252:37:252:58 | jca/Hash.java:252:37:252:58 | +| jca/Hash.java:266:32:266:40 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:266:32:266:40 | jca/Hash.java:266:32:266:40 | +| jca/Hash.java:266:32:266:40 | HashAlgorithm | Name | SHA2 | jca/Hash.java:266:32:266:40 | jca/Hash.java:266:32:266:40 | +| jca/Hash.java:266:32:266:40 | HashAlgorithm | RawName | SHA-256 | jca/Hash.java:266:32:266:40 | jca/Hash.java:266:32:266:40 | +| jca/Hash.java:266:43:266:51 | HashAlgorithm | DigestSize | 512 | jca/Hash.java:266:43:266:51 | jca/Hash.java:266:43:266:51 | +| jca/Hash.java:266:43:266:51 | HashAlgorithm | Name | SHA2 | jca/Hash.java:266:43:266:51 | jca/Hash.java:266:43:266:51 | +| jca/Hash.java:266:43:266:51 | HashAlgorithm | RawName | SHA-512 | jca/Hash.java:266:43:266:51 | jca/Hash.java:266:43:266:51 | +| jca/Hash.java:266:54:266:63 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:266:54:266:63 | jca/Hash.java:266:54:266:63 | +| jca/Hash.java:266:54:266:63 | HashAlgorithm | Name | SHA3 | jca/Hash.java:266:54:266:63 | jca/Hash.java:266:54:266:63 | +| jca/Hash.java:266:54:266:63 | HashAlgorithm | RawName | SHA3-256 | jca/Hash.java:266:54:266:63 | jca/Hash.java:266:54:266:63 | +| jca/Hash.java:266:66:266:75 | HashAlgorithm | DigestSize | 512 | jca/Hash.java:266:66:266:75 | jca/Hash.java:266:66:266:75 | +| jca/Hash.java:266:66:266:75 | HashAlgorithm | Name | SHA3 | jca/Hash.java:266:66:266:75 | jca/Hash.java:266:66:266:75 | +| jca/Hash.java:266:66:266:75 | HashAlgorithm | RawName | SHA3-512 | jca/Hash.java:266:66:266:75 | jca/Hash.java:266:66:266:75 | +| jca/Hash.java:269:27:269:38 | Constant | Description | "fixed-seed" | jca/Hash.java:269:27:269:38 | jca/Hash.java:269:27:269:38 | +| jca/Hash.java:294:16:294:66 | LocalData | Description | getProperty(...) | jca/Hash.java:294:16:294:66 | jca/Hash.java:294:16:294:66 | +| jca/Hash.java:294:57:294:65 | HashAlgorithm | DigestSize | 256 | jca/Hash.java:294:57:294:65 | jca/Hash.java:294:57:294:65 | +| jca/Hash.java:294:57:294:65 | HashAlgorithm | Name | SHA2 | jca/Hash.java:294:57:294:65 | jca/Hash.java:294:57:294:65 | +| jca/Hash.java:294:57:294:65 | HashAlgorithm | RawName | SHA-256 | jca/Hash.java:294:57:294:65 | jca/Hash.java:294:57:294:65 | +| jca/Hash.java:310:9:310:42 | RandomNumberGeneration | Description | nextBytes | jca/Hash.java:310:9:310:42 | jca/Hash.java:310:9:310:42 | +| jca/Hash.java:310:38:310:41 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/Hash.java:310:38:310:41 | jca/Hash.java:310:38:310:41 | +| jca/IVArtifact.java:30:44:30:65 | KeyOperationAlgorithm | Name | AES | jca/IVArtifact.java:30:44:30:65 | jca/IVArtifact.java:30:44:30:65 | +| jca/IVArtifact.java:30:44:30:65 | KeyOperationAlgorithm | RawName | AES/CBC/PKCS5Padding | jca/IVArtifact.java:30:44:30:65 | jca/IVArtifact.java:30:44:30:65 | +| jca/IVArtifact.java:30:44:30:65 | KeyOperationAlgorithm | Structure | Block | jca/IVArtifact.java:30:44:30:65 | jca/IVArtifact.java:30:44:30:65 | +| jca/IVArtifact.java:30:44:30:65 | ModeOfOperation | Name | CBC | jca/IVArtifact.java:30:44:30:65 | jca/IVArtifact.java:30:44:30:65 | +| jca/IVArtifact.java:30:44:30:65 | ModeOfOperation | RawName | CBC | jca/IVArtifact.java:30:44:30:65 | jca/IVArtifact.java:30:44:30:65 | +| jca/IVArtifact.java:30:44:30:65 | PaddingAlgorithm | Name | PKCS7 | jca/IVArtifact.java:30:44:30:65 | jca/IVArtifact.java:30:44:30:65 | +| jca/IVArtifact.java:30:44:30:65 | PaddingAlgorithm | RawName | PKCS5Padding | jca/IVArtifact.java:30:44:30:65 | jca/IVArtifact.java:30:44:30:65 | +| jca/IVArtifact.java:31:42:31:44 | Key | KeyType | Unknown | jca/IVArtifact.java:31:42:31:44 | jca/IVArtifact.java:31:42:31:44 | +| jca/IVArtifact.java:32:29:32:73 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/IVArtifact.java:32:29:32:73 | jca/IVArtifact.java:32:29:32:73 | +| jca/IVArtifact.java:32:44:32:61 | Constant | Description | "Simple Test Data" | jca/IVArtifact.java:32:44:32:61 | jca/IVArtifact.java:32:44:32:61 | +| jca/IVArtifact.java:38:42:38:44 | Key | KeyType | Unknown | jca/IVArtifact.java:38:42:38:44 | jca/IVArtifact.java:38:42:38:44 | +| jca/IVArtifact.java:39:29:39:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/IVArtifact.java:39:29:39:53 | jca/IVArtifact.java:39:29:39:53 | +| jca/IVArtifact.java:49:27:49:42 | Constant | Description | "Sensitive Data" | jca/IVArtifact.java:49:27:49:42 | jca/IVArtifact.java:49:27:49:42 | +| jca/IVArtifact.java:70:16:70:81 | LocalData | Description | getProperty(...) | jca/IVArtifact.java:70:16:70:81 | jca/IVArtifact.java:70:16:70:81 | +| jca/IVArtifact.java:70:59:70:80 | KeyOperationAlgorithm | Name | AES | jca/IVArtifact.java:70:59:70:80 | jca/IVArtifact.java:70:59:70:80 | +| jca/IVArtifact.java:70:59:70:80 | KeyOperationAlgorithm | RawName | AES/CBC/PKCS5Padding | jca/IVArtifact.java:70:59:70:80 | jca/IVArtifact.java:70:59:70:80 | +| jca/IVArtifact.java:70:59:70:80 | KeyOperationAlgorithm | Structure | Block | jca/IVArtifact.java:70:59:70:80 | jca/IVArtifact.java:70:59:70:80 | +| jca/IVArtifact.java:70:59:70:80 | ModeOfOperation | Name | CBC | jca/IVArtifact.java:70:59:70:80 | jca/IVArtifact.java:70:59:70:80 | +| jca/IVArtifact.java:70:59:70:80 | ModeOfOperation | RawName | CBC | jca/IVArtifact.java:70:59:70:80 | jca/IVArtifact.java:70:59:70:80 | +| jca/IVArtifact.java:70:59:70:80 | PaddingAlgorithm | Name | PKCS7 | jca/IVArtifact.java:70:59:70:80 | jca/IVArtifact.java:70:59:70:80 | +| jca/IVArtifact.java:70:59:70:80 | PaddingAlgorithm | RawName | PKCS5Padding | jca/IVArtifact.java:70:59:70:80 | jca/IVArtifact.java:70:59:70:80 | +| jca/IVArtifact.java:74:56:74:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/IVArtifact.java:75:21:75:23 | jca/IVArtifact.java:75:21:75:23 | +| jca/IVArtifact.java:74:56:74:60 | KeyOperationAlgorithm | Name | AES | jca/IVArtifact.java:74:56:74:60 | jca/IVArtifact.java:74:56:74:60 | +| jca/IVArtifact.java:74:56:74:60 | KeyOperationAlgorithm | RawName | AES | jca/IVArtifact.java:74:56:74:60 | jca/IVArtifact.java:74:56:74:60 | +| jca/IVArtifact.java:74:56:74:60 | KeyOperationAlgorithm | Structure | Block | jca/IVArtifact.java:74:56:74:60 | jca/IVArtifact.java:74:56:74:60 | +| jca/IVArtifact.java:75:21:75:23 | Constant | Description | 256 | jca/IVArtifact.java:75:21:75:23 | jca/IVArtifact.java:75:21:75:23 | +| jca/IVArtifact.java:76:16:76:35 | Key | KeyType | Symmetric | jca/IVArtifact.java:76:16:76:35 | jca/IVArtifact.java:76:16:76:35 | +| jca/IVArtifact.java:81:9:81:40 | RandomNumberGeneration | Description | nextBytes | jca/IVArtifact.java:81:9:81:40 | jca/IVArtifact.java:81:9:81:40 | +| jca/IVArtifact.java:81:38:81:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/IVArtifact.java:81:38:81:39 | jca/IVArtifact.java:81:38:81:39 | +| jca/IVArtifact.java:87:32:87:33 | RandomNumberGeneration | Description | java.util.Random | jca/IVArtifact.java:87:32:87:33 | jca/IVArtifact.java:87:32:87:33 | +| jca/IVArtifact.java:105:44:105:62 | KeyOperationAlgorithm | Name | AES | jca/IVArtifact.java:105:44:105:62 | jca/IVArtifact.java:105:44:105:62 | +| jca/IVArtifact.java:105:44:105:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/IVArtifact.java:105:44:105:62 | jca/IVArtifact.java:105:44:105:62 | +| jca/IVArtifact.java:105:44:105:62 | KeyOperationAlgorithm | Structure | Block | jca/IVArtifact.java:105:44:105:62 | jca/IVArtifact.java:105:44:105:62 | +| jca/IVArtifact.java:105:44:105:62 | ModeOfOperation | Name | GCM | jca/IVArtifact.java:105:44:105:62 | jca/IVArtifact.java:105:44:105:62 | +| jca/IVArtifact.java:105:44:105:62 | ModeOfOperation | RawName | GCM | jca/IVArtifact.java:105:44:105:62 | jca/IVArtifact.java:105:44:105:62 | +| jca/IVArtifact.java:105:44:105:62 | PaddingAlgorithm | Name | UnknownPadding | jca/IVArtifact.java:105:44:105:62 | jca/IVArtifact.java:105:44:105:62 | +| jca/IVArtifact.java:105:44:105:62 | PaddingAlgorithm | RawName | NoPadding | jca/IVArtifact.java:105:44:105:62 | jca/IVArtifact.java:105:44:105:62 | +| jca/IVArtifact.java:108:42:108:44 | Key | KeyType | Unknown | jca/IVArtifact.java:108:42:108:44 | jca/IVArtifact.java:108:42:108:44 | +| jca/IVArtifact.java:109:16:109:40 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/IVArtifact.java:109:16:109:40 | jca/IVArtifact.java:109:16:109:40 | +| jca/IVArtifact.java:116:31:116:34 | Constant | Description | null | jca/IVArtifact.java:116:31:116:34 | jca/IVArtifact.java:116:31:116:34 | +| jca/IVArtifact.java:130:13:130:50 | RandomNumberGeneration | Description | nextBytes | jca/IVArtifact.java:130:13:130:50 | jca/IVArtifact.java:130:13:130:50 | +| jca/IVArtifact.java:130:42:130:49 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/IVArtifact.java:130:42:130:49 | jca/IVArtifact.java:130:42:130:49 | +| jca/IVArtifact.java:132:44:132:62 | KeyOperationAlgorithm | Name | AES | jca/IVArtifact.java:132:44:132:62 | jca/IVArtifact.java:132:44:132:62 | +| jca/IVArtifact.java:132:44:132:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/IVArtifact.java:132:44:132:62 | jca/IVArtifact.java:132:44:132:62 | +| jca/IVArtifact.java:132:44:132:62 | KeyOperationAlgorithm | Structure | Block | jca/IVArtifact.java:132:44:132:62 | jca/IVArtifact.java:132:44:132:62 | +| jca/IVArtifact.java:132:44:132:62 | ModeOfOperation | Name | GCM | jca/IVArtifact.java:132:44:132:62 | jca/IVArtifact.java:132:44:132:62 | +| jca/IVArtifact.java:132:44:132:62 | ModeOfOperation | RawName | GCM | jca/IVArtifact.java:132:44:132:62 | jca/IVArtifact.java:132:44:132:62 | +| jca/IVArtifact.java:132:44:132:62 | PaddingAlgorithm | Name | UnknownPadding | jca/IVArtifact.java:132:44:132:62 | jca/IVArtifact.java:132:44:132:62 | +| jca/IVArtifact.java:132:44:132:62 | PaddingAlgorithm | RawName | NoPadding | jca/IVArtifact.java:132:44:132:62 | jca/IVArtifact.java:132:44:132:62 | +| jca/IVArtifact.java:134:42:134:44 | Key | KeyType | Unknown | jca/IVArtifact.java:134:42:134:44 | jca/IVArtifact.java:134:42:134:44 | +| jca/IVArtifact.java:135:16:135:40 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/IVArtifact.java:135:16:135:40 | jca/IVArtifact.java:135:16:135:40 | +| jca/IVArtifact.java:153:58:153:66 | HashAlgorithm | DigestSize | 256 | jca/IVArtifact.java:153:58:153:66 | jca/IVArtifact.java:153:58:153:66 | +| jca/IVArtifact.java:153:58:153:66 | HashAlgorithm | Name | SHA2 | jca/IVArtifact.java:153:58:153:66 | jca/IVArtifact.java:153:58:153:66 | +| jca/IVArtifact.java:153:58:153:66 | HashAlgorithm | RawName | SHA-256 | jca/IVArtifact.java:153:58:153:66 | jca/IVArtifact.java:153:58:153:66 | +| jca/IVArtifact.java:154:45:154:59 | Constant | Description | "fixedConstant" | jca/IVArtifact.java:154:45:154:59 | jca/IVArtifact.java:154:45:154:59 | +| jca/IVArtifact.java:156:44:156:62 | KeyOperationAlgorithm | Name | AES | jca/IVArtifact.java:156:44:156:62 | jca/IVArtifact.java:156:44:156:62 | +| jca/IVArtifact.java:156:44:156:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/IVArtifact.java:156:44:156:62 | jca/IVArtifact.java:156:44:156:62 | +| jca/IVArtifact.java:156:44:156:62 | KeyOperationAlgorithm | Structure | Block | jca/IVArtifact.java:156:44:156:62 | jca/IVArtifact.java:156:44:156:62 | +| jca/IVArtifact.java:156:44:156:62 | ModeOfOperation | Name | GCM | jca/IVArtifact.java:156:44:156:62 | jca/IVArtifact.java:156:44:156:62 | +| jca/IVArtifact.java:156:44:156:62 | ModeOfOperation | RawName | GCM | jca/IVArtifact.java:156:44:156:62 | jca/IVArtifact.java:156:44:156:62 | +| jca/IVArtifact.java:156:44:156:62 | PaddingAlgorithm | Name | UnknownPadding | jca/IVArtifact.java:156:44:156:62 | jca/IVArtifact.java:156:44:156:62 | +| jca/IVArtifact.java:156:44:156:62 | PaddingAlgorithm | RawName | NoPadding | jca/IVArtifact.java:156:44:156:62 | jca/IVArtifact.java:156:44:156:62 | +| jca/IVArtifact.java:158:42:158:44 | Key | KeyType | Unknown | jca/IVArtifact.java:158:42:158:44 | jca/IVArtifact.java:158:42:158:44 | +| jca/IVArtifact.java:159:16:159:40 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/IVArtifact.java:159:16:159:40 | jca/IVArtifact.java:159:16:159:40 | +| jca/IVArtifact.java:177:9:177:40 | RandomNumberGeneration | Description | nextBytes | jca/IVArtifact.java:177:9:177:40 | jca/IVArtifact.java:177:9:177:40 | +| jca/IVArtifact.java:177:38:177:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/IVArtifact.java:177:38:177:39 | jca/IVArtifact.java:177:38:177:39 | +| jca/IVArtifact.java:180:48:180:66 | KeyOperationAlgorithm | Name | AES | jca/IVArtifact.java:180:48:180:66 | jca/IVArtifact.java:180:48:180:66 | +| jca/IVArtifact.java:180:48:180:66 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/IVArtifact.java:180:48:180:66 | jca/IVArtifact.java:180:48:180:66 | +| jca/IVArtifact.java:180:48:180:66 | KeyOperationAlgorithm | Structure | Block | jca/IVArtifact.java:180:48:180:66 | jca/IVArtifact.java:180:48:180:66 | +| jca/IVArtifact.java:180:48:180:66 | ModeOfOperation | Name | GCM | jca/IVArtifact.java:180:48:180:66 | jca/IVArtifact.java:180:48:180:66 | +| jca/IVArtifact.java:180:48:180:66 | ModeOfOperation | RawName | GCM | jca/IVArtifact.java:180:48:180:66 | jca/IVArtifact.java:180:48:180:66 | +| jca/IVArtifact.java:180:48:180:66 | PaddingAlgorithm | Name | UnknownPadding | jca/IVArtifact.java:180:48:180:66 | jca/IVArtifact.java:180:48:180:66 | +| jca/IVArtifact.java:180:48:180:66 | PaddingAlgorithm | RawName | NoPadding | jca/IVArtifact.java:180:48:180:66 | jca/IVArtifact.java:180:48:180:66 | +| jca/IVArtifact.java:182:46:182:48 | Key | KeyType | Unknown | jca/IVArtifact.java:182:46:182:48 | jca/IVArtifact.java:182:46:182:48 | +| jca/IVArtifact.java:183:30:183:58 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/IVArtifact.java:183:30:183:58 | jca/IVArtifact.java:183:30:183:58 | +| jca/IVArtifact.java:198:44:198:62 | KeyOperationAlgorithm | Name | AES | jca/IVArtifact.java:198:44:198:62 | jca/IVArtifact.java:198:44:198:62 | +| jca/IVArtifact.java:198:44:198:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/IVArtifact.java:198:44:198:62 | jca/IVArtifact.java:198:44:198:62 | +| jca/IVArtifact.java:198:44:198:62 | KeyOperationAlgorithm | Structure | Block | jca/IVArtifact.java:198:44:198:62 | jca/IVArtifact.java:198:44:198:62 | +| jca/IVArtifact.java:198:44:198:62 | ModeOfOperation | Name | GCM | jca/IVArtifact.java:198:44:198:62 | jca/IVArtifact.java:198:44:198:62 | +| jca/IVArtifact.java:198:44:198:62 | ModeOfOperation | RawName | GCM | jca/IVArtifact.java:198:44:198:62 | jca/IVArtifact.java:198:44:198:62 | +| jca/IVArtifact.java:198:44:198:62 | PaddingAlgorithm | Name | UnknownPadding | jca/IVArtifact.java:198:44:198:62 | jca/IVArtifact.java:198:44:198:62 | +| jca/IVArtifact.java:198:44:198:62 | PaddingAlgorithm | RawName | NoPadding | jca/IVArtifact.java:198:44:198:62 | jca/IVArtifact.java:198:44:198:62 | +| jca/IVArtifact.java:201:42:201:44 | Key | KeyType | Unknown | jca/IVArtifact.java:201:42:201:44 | jca/IVArtifact.java:201:42:201:44 | +| jca/IVArtifact.java:202:16:202:40 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/IVArtifact.java:202:16:202:40 | jca/IVArtifact.java:202:16:202:40 | +| jca/IVArtifact.java:215:53:215:65 | Parameter | Description | key | jca/IVArtifact.java:215:53:215:65 | jca/IVArtifact.java:215:53:215:65 | +| jca/IVArtifact.java:215:68:215:83 | Parameter | Description | plaintext | jca/IVArtifact.java:215:68:215:83 | jca/IVArtifact.java:215:68:215:83 | +| jca/IVArtifact.java:235:60:235:72 | Parameter | Description | key | jca/IVArtifact.java:235:60:235:72 | jca/IVArtifact.java:235:60:235:72 | +| jca/IVArtifact.java:235:75:235:90 | Parameter | Description | plaintext | jca/IVArtifact.java:235:75:235:90 | jca/IVArtifact.java:235:75:235:90 | +| jca/IVArtifact.java:253:56:253:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/IVArtifact.java:254:21:254:23 | jca/IVArtifact.java:254:21:254:23 | +| jca/IVArtifact.java:253:56:253:60 | KeyOperationAlgorithm | Name | AES | jca/IVArtifact.java:253:56:253:60 | jca/IVArtifact.java:253:56:253:60 | +| jca/IVArtifact.java:253:56:253:60 | KeyOperationAlgorithm | RawName | AES | jca/IVArtifact.java:253:56:253:60 | jca/IVArtifact.java:253:56:253:60 | +| jca/IVArtifact.java:253:56:253:60 | KeyOperationAlgorithm | Structure | Block | jca/IVArtifact.java:253:56:253:60 | jca/IVArtifact.java:253:56:253:60 | +| jca/IVArtifact.java:254:21:254:23 | Constant | Description | 256 | jca/IVArtifact.java:254:21:254:23 | jca/IVArtifact.java:254:21:254:23 | +| jca/IVArtifact.java:255:29:255:44 | Key | KeyType | Symmetric | jca/IVArtifact.java:255:29:255:44 | jca/IVArtifact.java:255:29:255:44 | +| jca/IVArtifact.java:256:32:256:47 | Constant | Description | "Sensitive Data" | jca/IVArtifact.java:256:32:256:47 | jca/IVArtifact.java:256:32:256:47 | +| jca/IVArtifact.java:275:34:275:46 | Constant | Description | "Message One" | jca/IVArtifact.java:275:34:275:46 | jca/IVArtifact.java:275:34:275:46 | +| jca/IVArtifact.java:275:60:275:72 | Constant | Description | "Message Two" | jca/IVArtifact.java:275:60:275:72 | jca/IVArtifact.java:275:60:275:72 | +| jca/IVArtifact.java:275:86:275:100 | Constant | Description | "Message Three" | jca/IVArtifact.java:275:86:275:100 | jca/IVArtifact.java:275:86:275:100 | +| jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | EllipticCurve | KeySize | 256 | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | +| jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | EllipticCurve | Name | secp256r1 | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | +| jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | EllipticCurve | ParsedName | secp256r1 | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | +| jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | EllipticCurve | RawName | secp256r1 | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | +| jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | Key | KeyType | Asymmetric | jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | +| jca/KeyAgreementHybridCryptosystem.java:58:61:58:68 | KeyAgreementAlgorithm | Name | X25519 | jca/KeyAgreementHybridCryptosystem.java:58:61:58:68 | jca/KeyAgreementHybridCryptosystem.java:58:61:58:68 | +| jca/KeyAgreementHybridCryptosystem.java:58:61:58:68 | KeyAgreementAlgorithm | RawName | X25519 | jca/KeyAgreementHybridCryptosystem.java:58:61:58:68 | jca/KeyAgreementHybridCryptosystem.java:58:61:58:68 | +| jca/KeyAgreementHybridCryptosystem.java:59:24:59:26 | Constant | Description | 255 | jca/KeyAgreementHybridCryptosystem.java:59:24:59:26 | jca/KeyAgreementHybridCryptosystem.java:59:24:59:26 | +| jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | Key | KeyType | Asymmetric | jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | +| jca/KeyAgreementHybridCryptosystem.java:68:17:68:26 | Key | KeyType | Unknown | jca/KeyAgreementHybridCryptosystem.java:68:17:68:26 | jca/KeyAgreementHybridCryptosystem.java:68:17:68:26 | +| jca/KeyAgreementHybridCryptosystem.java:69:20:69:28 | Key | KeyType | Unknown | jca/KeyAgreementHybridCryptosystem.java:69:20:69:28 | jca/KeyAgreementHybridCryptosystem.java:69:20:69:28 | +| jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | HashAlgorithm | DigestSize | 256 | jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | +| jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | HashAlgorithm | Name | SHA2 | jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | +| jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | HashAlgorithm | RawName | SHA-256 | jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | +| jca/KeyAgreementHybridCryptosystem.java:104:90:104:95 | KeyAgreementAlgorithm | Name | ECDH | jca/KeyAgreementHybridCryptosystem.java:104:90:104:95 | jca/KeyAgreementHybridCryptosystem.java:104:90:104:95 | +| jca/KeyAgreementHybridCryptosystem.java:104:90:104:95 | KeyAgreementAlgorithm | RawName | ECDH | jca/KeyAgreementHybridCryptosystem.java:104:90:104:95 | jca/KeyAgreementHybridCryptosystem.java:104:90:104:95 | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | KeyOperationAlgorithm | Name | AES | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | KeyOperationAlgorithm | Structure | Block | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | ModeOfOperation | Name | GCM | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | ModeOfOperation | RawName | GCM | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | PaddingAlgorithm | Name | UnknownPadding | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | PaddingAlgorithm | RawName | NoPadding | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | +| jca/KeyAgreementHybridCryptosystem.java:110:9:110:40 | RandomNumberGeneration | Description | nextBytes | jca/KeyAgreementHybridCryptosystem.java:110:9:110:40 | jca/KeyAgreementHybridCryptosystem.java:110:9:110:40 | +| jca/KeyAgreementHybridCryptosystem.java:110:38:110:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/KeyAgreementHybridCryptosystem.java:110:38:110:39 | jca/KeyAgreementHybridCryptosystem.java:110:38:110:39 | +| jca/KeyAgreementHybridCryptosystem.java:112:42:112:47 | Key | KeyType | Unknown | jca/KeyAgreementHybridCryptosystem.java:112:42:112:47 | jca/KeyAgreementHybridCryptosystem.java:112:42:112:47 | +| jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | +| jca/KeyAgreementHybridCryptosystem.java:125:95:125:100 | KeyAgreementAlgorithm | Name | ECDH | jca/KeyAgreementHybridCryptosystem.java:125:95:125:100 | jca/KeyAgreementHybridCryptosystem.java:125:95:125:100 | +| jca/KeyAgreementHybridCryptosystem.java:125:95:125:100 | KeyAgreementAlgorithm | RawName | ECDH | jca/KeyAgreementHybridCryptosystem.java:125:95:125:100 | jca/KeyAgreementHybridCryptosystem.java:125:95:125:100 | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | KeyOperationAlgorithm | Name | AES | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | KeyOperationAlgorithm | Structure | Block | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | ModeOfOperation | Name | GCM | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | ModeOfOperation | RawName | GCM | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | PaddingAlgorithm | Name | UnknownPadding | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | PaddingAlgorithm | RawName | NoPadding | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | +| jca/KeyAgreementHybridCryptosystem.java:132:42:132:47 | Key | KeyType | Unknown | jca/KeyAgreementHybridCryptosystem.java:132:42:132:47 | jca/KeyAgreementHybridCryptosystem.java:132:42:132:47 | +| jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | +| jca/KeyAgreementHybridCryptosystem.java:149:91:149:98 | KeyAgreementAlgorithm | Name | X25519 | jca/KeyAgreementHybridCryptosystem.java:149:91:149:98 | jca/KeyAgreementHybridCryptosystem.java:149:91:149:98 | +| jca/KeyAgreementHybridCryptosystem.java:149:91:149:98 | KeyAgreementAlgorithm | RawName | X25519 | jca/KeyAgreementHybridCryptosystem.java:149:91:149:98 | jca/KeyAgreementHybridCryptosystem.java:149:91:149:98 | +| jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | HashAlgorithm | DigestSize | 256 | jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | +| jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | HashAlgorithm | Name | SHA2 | jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | +| jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | HashAlgorithm | RawName | SHA-256 | jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | +| jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | KeyOperationAlgorithm | Name | Unknown | jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | +| jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | KeyOperationAlgorithm | RawName | ChaCha20-Poly1305 | jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | +| jca/KeyAgreementHybridCryptosystem.java:155:9:155:43 | RandomNumberGeneration | Description | nextBytes | jca/KeyAgreementHybridCryptosystem.java:155:9:155:43 | jca/KeyAgreementHybridCryptosystem.java:155:9:155:43 | +| jca/KeyAgreementHybridCryptosystem.java:155:38:155:42 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/KeyAgreementHybridCryptosystem.java:155:38:155:42 | jca/KeyAgreementHybridCryptosystem.java:155:38:155:42 | +| jca/KeyAgreementHybridCryptosystem.java:156:42:156:50 | Key | KeyType | Unknown | jca/KeyAgreementHybridCryptosystem.java:156:42:156:50 | jca/KeyAgreementHybridCryptosystem.java:156:42:156:50 | +| jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | +| jca/KeyAgreementHybridCryptosystem.java:169:95:169:102 | KeyAgreementAlgorithm | Name | X25519 | jca/KeyAgreementHybridCryptosystem.java:169:95:169:102 | jca/KeyAgreementHybridCryptosystem.java:169:95:169:102 | +| jca/KeyAgreementHybridCryptosystem.java:169:95:169:102 | KeyAgreementAlgorithm | RawName | X25519 | jca/KeyAgreementHybridCryptosystem.java:169:95:169:102 | jca/KeyAgreementHybridCryptosystem.java:169:95:169:102 | +| jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | KeyOperationAlgorithm | Name | Unknown | jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | +| jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | KeyOperationAlgorithm | RawName | ChaCha20-Poly1305 | jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | +| jca/KeyAgreementHybridCryptosystem.java:175:42:175:50 | Key | KeyType | Unknown | jca/KeyAgreementHybridCryptosystem.java:175:42:175:50 | jca/KeyAgreementHybridCryptosystem.java:175:42:175:50 | +| jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | +| jca/KeyAgreementHybridCryptosystem.java:188:58:188:73 | Parameter | Description | plaintext | jca/KeyAgreementHybridCryptosystem.java:188:58:188:73 | jca/KeyAgreementHybridCryptosystem.java:188:58:188:73 | +| jca/KeyAgreementHybridCryptosystem.java:212:58:212:70 | Parameter | Description | key | jca/KeyAgreementHybridCryptosystem.java:212:58:212:70 | jca/KeyAgreementHybridCryptosystem.java:212:58:212:70 | +| jca/KeyAgreementHybridCryptosystem.java:212:73:212:88 | Parameter | Description | plaintext | jca/KeyAgreementHybridCryptosystem.java:212:73:212:88 | jca/KeyAgreementHybridCryptosystem.java:212:73:212:88 | +| jca/KeyAgreementHybridCryptosystem.java:215:75:215:79 | Constant | Description | 10000 | jca/KeyAgreementHybridCryptosystem.java:215:75:215:79 | jca/KeyAgreementHybridCryptosystem.java:215:75:215:79 | +| jca/KeyAgreementHybridCryptosystem.java:215:82:215:84 | Constant | Description | 256 | jca/KeyAgreementHybridCryptosystem.java:215:82:215:84 | jca/KeyAgreementHybridCryptosystem.java:215:82:215:84 | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HMACAlgorithm | Name | HMAC | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HashAlgorithm | DigestSize | 256 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HashAlgorithm | Name | SHA2 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | +| jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | Key | KeyType | Symmetric | jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | +| jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | KeyDerivation | Iterations | Constant:10000 | jca/KeyAgreementHybridCryptosystem.java:215:75:215:79 | jca/KeyAgreementHybridCryptosystem.java:215:75:215:79 | +| jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | KeyDerivation | KeySize | Constant:256 | jca/KeyAgreementHybridCryptosystem.java:215:82:215:84 | jca/KeyAgreementHybridCryptosystem.java:215:82:215:84 | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | KeyOperationAlgorithm | Name | AES | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | KeyOperationAlgorithm | Structure | Block | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | ModeOfOperation | Name | GCM | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | ModeOfOperation | RawName | GCM | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | PaddingAlgorithm | Name | UnknownPadding | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | PaddingAlgorithm | RawName | NoPadding | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | +| jca/KeyAgreementHybridCryptosystem.java:225:9:225:40 | RandomNumberGeneration | Description | nextBytes | jca/KeyAgreementHybridCryptosystem.java:225:9:225:40 | jca/KeyAgreementHybridCryptosystem.java:225:9:225:40 | +| jca/KeyAgreementHybridCryptosystem.java:225:38:225:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/KeyAgreementHybridCryptosystem.java:225:38:225:39 | jca/KeyAgreementHybridCryptosystem.java:225:38:225:39 | +| jca/KeyAgreementHybridCryptosystem.java:227:42:227:54 | Key | KeyType | Unknown | jca/KeyAgreementHybridCryptosystem.java:227:42:227:54 | jca/KeyAgreementHybridCryptosystem.java:227:42:227:54 | +| jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | +| jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | KeyOperationAlgorithm | Name | HMAC | jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | +| jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | +| jca/KeyAgreementHybridCryptosystem.java:231:18:231:30 | Key | KeyType | Unknown | jca/KeyAgreementHybridCryptosystem.java:231:18:231:30 | jca/KeyAgreementHybridCryptosystem.java:231:18:231:30 | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | KeyOperationSubtype | Mac | jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | +| jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/KeyAgreementHybridCryptosystem.java:260:17:260:19 | jca/KeyAgreementHybridCryptosystem.java:260:17:260:19 | +| jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | KeyOperationAlgorithm | Name | AES | jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | +| jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | KeyOperationAlgorithm | RawName | AES | jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | +| jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | KeyOperationAlgorithm | Structure | Block | jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | +| jca/KeyAgreementHybridCryptosystem.java:260:17:260:19 | Constant | Description | 256 | jca/KeyAgreementHybridCryptosystem.java:260:17:260:19 | jca/KeyAgreementHybridCryptosystem.java:260:17:260:19 | +| jca/KeyAgreementHybridCryptosystem.java:261:16:261:31 | Key | KeyType | Symmetric | jca/KeyAgreementHybridCryptosystem.java:261:16:261:31 | jca/KeyAgreementHybridCryptosystem.java:261:16:261:31 | +| jca/KeyAgreementHybridCryptosystem.java:269:9:269:42 | RandomNumberGeneration | Description | nextBytes | jca/KeyAgreementHybridCryptosystem.java:269:9:269:42 | jca/KeyAgreementHybridCryptosystem.java:269:9:269:42 | +| jca/KeyAgreementHybridCryptosystem.java:269:38:269:41 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/KeyAgreementHybridCryptosystem.java:269:38:269:41 | jca/KeyAgreementHybridCryptosystem.java:269:38:269:41 | +| jca/KeyArtifact.java:18:56:18:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/KeyArtifact.java:19:21:19:23 | jca/KeyArtifact.java:19:21:19:23 | +| jca/KeyArtifact.java:18:56:18:60 | KeyOperationAlgorithm | Name | AES | jca/KeyArtifact.java:18:56:18:60 | jca/KeyArtifact.java:18:56:18:60 | +| jca/KeyArtifact.java:18:56:18:60 | KeyOperationAlgorithm | RawName | AES | jca/KeyArtifact.java:18:56:18:60 | jca/KeyArtifact.java:18:56:18:60 | +| jca/KeyArtifact.java:18:56:18:60 | KeyOperationAlgorithm | Structure | Block | jca/KeyArtifact.java:18:56:18:60 | jca/KeyArtifact.java:18:56:18:60 | +| jca/KeyArtifact.java:19:21:19:23 | Constant | Description | 256 | jca/KeyArtifact.java:19:21:19:23 | jca/KeyArtifact.java:19:21:19:23 | +| jca/KeyArtifact.java:20:31:20:50 | Key | KeyType | Symmetric | jca/KeyArtifact.java:20:31:20:50 | jca/KeyArtifact.java:20:31:20:50 | +| jca/KeyArtifact.java:23:43:23:47 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/KeyArtifact.java:24:21:24:23 | jca/KeyArtifact.java:24:21:24:23 | +| jca/KeyArtifact.java:23:43:23:47 | KeyOperationAlgorithm | Name | AES | jca/KeyArtifact.java:23:43:23:47 | jca/KeyArtifact.java:23:43:23:47 | +| jca/KeyArtifact.java:23:43:23:47 | KeyOperationAlgorithm | RawName | AES | jca/KeyArtifact.java:23:43:23:47 | jca/KeyArtifact.java:23:43:23:47 | +| jca/KeyArtifact.java:23:43:23:47 | KeyOperationAlgorithm | Structure | Block | jca/KeyArtifact.java:23:43:23:47 | jca/KeyArtifact.java:23:43:23:47 | +| jca/KeyArtifact.java:24:21:24:23 | Constant | Description | 256 | jca/KeyArtifact.java:24:21:24:23 | jca/KeyArtifact.java:24:21:24:23 | +| jca/KeyArtifact.java:25:30:25:49 | Key | KeyType | Symmetric | jca/KeyArtifact.java:25:30:25:49 | jca/KeyArtifact.java:25:30:25:49 | +| jca/KeyArtifact.java:30:68:30:72 | KeyOperationAlgorithm | KeySize | Constant:2048 | jca/KeyArtifact.java:31:31:31:34 | jca/KeyArtifact.java:31:31:31:34 | +| jca/KeyArtifact.java:30:68:30:72 | KeyOperationAlgorithm | Name | RSA | jca/KeyArtifact.java:30:68:30:72 | jca/KeyArtifact.java:30:68:30:72 | +| jca/KeyArtifact.java:30:68:30:72 | KeyOperationAlgorithm | RawName | RSA | jca/KeyArtifact.java:30:68:30:72 | jca/KeyArtifact.java:30:68:30:72 | +| jca/KeyArtifact.java:31:31:31:34 | Constant | Description | 2048 | jca/KeyArtifact.java:31:31:31:34 | jca/KeyArtifact.java:31:31:31:34 | +| jca/KeyArtifact.java:32:30:32:57 | Key | KeyType | Asymmetric | jca/KeyArtifact.java:32:30:32:57 | jca/KeyArtifact.java:32:30:32:57 | +| jca/KeyArtifact.java:35:51:35:55 | KeyOperationAlgorithm | KeySize | Constant:2048 | jca/KeyArtifact.java:36:31:36:34 | jca/KeyArtifact.java:36:31:36:34 | +| jca/KeyArtifact.java:35:51:35:55 | KeyOperationAlgorithm | Name | RSA | jca/KeyArtifact.java:35:51:35:55 | jca/KeyArtifact.java:35:51:35:55 | +| jca/KeyArtifact.java:35:51:35:55 | KeyOperationAlgorithm | RawName | RSA | jca/KeyArtifact.java:35:51:35:55 | jca/KeyArtifact.java:35:51:35:55 | +| jca/KeyArtifact.java:36:31:36:34 | Constant | Description | 2048 | jca/KeyArtifact.java:36:31:36:34 | jca/KeyArtifact.java:36:31:36:34 | +| jca/KeyArtifact.java:37:29:37:56 | Key | KeyType | Asymmetric | jca/KeyArtifact.java:37:29:37:56 | jca/KeyArtifact.java:37:29:37:56 | +| jca/KeyArtifact.java:41:31:41:33 | Constant | Description | 256 | jca/KeyArtifact.java:41:31:41:33 | jca/KeyArtifact.java:41:31:41:33 | +| jca/KeyArtifact.java:42:26:42:53 | Key | KeyType | Asymmetric | jca/KeyArtifact.java:42:26:42:53 | jca/KeyArtifact.java:42:26:42:53 | +| jca/KeyArtifact.java:62:28:62:73 | LocalData | Description | getProperty(...) | jca/KeyArtifact.java:62:28:62:73 | jca/KeyArtifact.java:62:28:62:73 | +| jca/KeyArtifact.java:62:68:62:72 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/KeyArtifact.java:65:21:65:23 | jca/KeyArtifact.java:65:21:65:23 | +| jca/KeyArtifact.java:62:68:62:72 | KeyOperationAlgorithm | Name | AES | jca/KeyArtifact.java:62:68:62:72 | jca/KeyArtifact.java:62:68:62:72 | +| jca/KeyArtifact.java:62:68:62:72 | KeyOperationAlgorithm | RawName | AES | jca/KeyArtifact.java:62:68:62:72 | jca/KeyArtifact.java:62:68:62:72 | +| jca/KeyArtifact.java:62:68:62:72 | KeyOperationAlgorithm | Structure | Block | jca/KeyArtifact.java:62:68:62:72 | jca/KeyArtifact.java:62:68:62:72 | +| jca/KeyArtifact.java:65:21:65:23 | Constant | Description | 256 | jca/KeyArtifact.java:65:21:65:23 | jca/KeyArtifact.java:65:21:65:23 | +| jca/KeyArtifact.java:66:32:66:51 | Key | KeyType | Symmetric | jca/KeyArtifact.java:66:32:66:51 | jca/KeyArtifact.java:66:32:66:51 | +| jca/KeyArtifact.java:72:31:72:34 | Constant | Description | 2048 | jca/KeyArtifact.java:72:31:72:34 | jca/KeyArtifact.java:72:31:72:34 | +| jca/KeyArtifact.java:73:16:73:43 | Key | KeyType | Asymmetric | jca/KeyArtifact.java:73:16:73:43 | jca/KeyArtifact.java:73:16:73:43 | +| jca/KeyArtifact.java:78:32:78:36 | KeyOperationAlgorithm | KeySize | Constant:2048 | jca/KeyArtifact.java:72:31:72:34 | jca/KeyArtifact.java:72:31:72:34 | +| jca/KeyArtifact.java:78:32:78:36 | KeyOperationAlgorithm | Name | RSA | jca/KeyArtifact.java:78:32:78:36 | jca/KeyArtifact.java:78:32:78:36 | +| jca/KeyArtifact.java:78:32:78:36 | KeyOperationAlgorithm | RawName | RSA | jca/KeyArtifact.java:78:32:78:36 | jca/KeyArtifact.java:78:32:78:36 | +| jca/KeyArtifact.java:78:45:78:53 | Constant | Description | "Ed25519" | jca/KeyArtifact.java:78:45:78:53 | jca/KeyArtifact.java:78:45:78:53 | +| jca/KeyDerivation1.java:78:39:78:53 | Parameter | Description | password | jca/KeyDerivation1.java:78:39:78:53 | jca/KeyDerivation1.java:78:39:78:53 | +| jca/KeyDerivation1.java:80:72:80:76 | Constant | Description | 10000 | jca/KeyDerivation1.java:80:72:80:76 | jca/KeyDerivation1.java:80:72:80:76 | +| jca/KeyDerivation1.java:80:79:80:81 | Constant | Description | 256 | jca/KeyDerivation1.java:80:79:80:81 | jca/KeyDerivation1.java:80:79:80:81 | +| jca/KeyDerivation1.java:81:65:81:86 | HMACAlgorithm | Name | HMAC | jca/KeyDerivation1.java:81:65:81:86 | jca/KeyDerivation1.java:81:65:81:86 | +| jca/KeyDerivation1.java:81:65:81:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:81:65:81:86 | jca/KeyDerivation1.java:81:65:81:86 | +| jca/KeyDerivation1.java:81:65:81:86 | HashAlgorithm | DigestSize | 256 | jca/KeyDerivation1.java:81:65:81:86 | jca/KeyDerivation1.java:81:65:81:86 | +| jca/KeyDerivation1.java:81:65:81:86 | HashAlgorithm | Name | SHA2 | jca/KeyDerivation1.java:81:65:81:86 | jca/KeyDerivation1.java:81:65:81:86 | +| jca/KeyDerivation1.java:81:65:81:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:81:65:81:86 | jca/KeyDerivation1.java:81:65:81:86 | +| jca/KeyDerivation1.java:81:65:81:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:81:65:81:86 | jca/KeyDerivation1.java:81:65:81:86 | +| jca/KeyDerivation1.java:81:65:81:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:81:65:81:86 | jca/KeyDerivation1.java:81:65:81:86 | +| jca/KeyDerivation1.java:82:22:82:49 | Key | KeyType | Symmetric | jca/KeyDerivation1.java:82:22:82:49 | jca/KeyDerivation1.java:82:22:82:49 | +| jca/KeyDerivation1.java:82:22:82:49 | KeyDerivation | Iterations | Constant:10000 | jca/KeyDerivation1.java:80:72:80:76 | jca/KeyDerivation1.java:80:72:80:76 | +| jca/KeyDerivation1.java:82:22:82:49 | KeyDerivation | KeySize | Constant:256 | jca/KeyDerivation1.java:80:79:80:81 | jca/KeyDerivation1.java:80:79:80:81 | +| jca/KeyDerivation1.java:92:36:92:50 | Parameter | Description | password | jca/KeyDerivation1.java:92:36:92:50 | jca/KeyDerivation1.java:92:36:92:50 | +| jca/KeyDerivation1.java:94:72:94:73 | Constant | Description | 10 | jca/KeyDerivation1.java:94:72:94:73 | jca/KeyDerivation1.java:94:72:94:73 | +| jca/KeyDerivation1.java:94:76:94:78 | Constant | Description | 256 | jca/KeyDerivation1.java:94:76:94:78 | jca/KeyDerivation1.java:94:76:94:78 | +| jca/KeyDerivation1.java:95:65:95:86 | HMACAlgorithm | Name | HMAC | jca/KeyDerivation1.java:95:65:95:86 | jca/KeyDerivation1.java:95:65:95:86 | +| jca/KeyDerivation1.java:95:65:95:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:95:65:95:86 | jca/KeyDerivation1.java:95:65:95:86 | +| jca/KeyDerivation1.java:95:65:95:86 | HashAlgorithm | DigestSize | 256 | jca/KeyDerivation1.java:95:65:95:86 | jca/KeyDerivation1.java:95:65:95:86 | +| jca/KeyDerivation1.java:95:65:95:86 | HashAlgorithm | Name | SHA2 | jca/KeyDerivation1.java:95:65:95:86 | jca/KeyDerivation1.java:95:65:95:86 | +| jca/KeyDerivation1.java:95:65:95:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:95:65:95:86 | jca/KeyDerivation1.java:95:65:95:86 | +| jca/KeyDerivation1.java:95:65:95:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:95:65:95:86 | jca/KeyDerivation1.java:95:65:95:86 | +| jca/KeyDerivation1.java:95:65:95:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:95:65:95:86 | jca/KeyDerivation1.java:95:65:95:86 | +| jca/KeyDerivation1.java:96:22:96:49 | Key | KeyType | Symmetric | jca/KeyDerivation1.java:96:22:96:49 | jca/KeyDerivation1.java:96:22:96:49 | +| jca/KeyDerivation1.java:96:22:96:49 | KeyDerivation | Iterations | Constant:10 | jca/KeyDerivation1.java:94:72:94:73 | jca/KeyDerivation1.java:94:72:94:73 | +| jca/KeyDerivation1.java:96:22:96:49 | KeyDerivation | KeySize | Constant:256 | jca/KeyDerivation1.java:94:76:94:78 | jca/KeyDerivation1.java:94:76:94:78 | +| jca/KeyDerivation1.java:106:37:106:51 | Parameter | Description | password | jca/KeyDerivation1.java:106:37:106:51 | jca/KeyDerivation1.java:106:37:106:51 | +| jca/KeyDerivation1.java:108:72:108:80 | Constant | Description | 1_000_000 | jca/KeyDerivation1.java:108:72:108:80 | jca/KeyDerivation1.java:108:72:108:80 | +| jca/KeyDerivation1.java:108:83:108:85 | Constant | Description | 256 | jca/KeyDerivation1.java:108:83:108:85 | jca/KeyDerivation1.java:108:83:108:85 | +| jca/KeyDerivation1.java:109:65:109:86 | HMACAlgorithm | Name | HMAC | jca/KeyDerivation1.java:109:65:109:86 | jca/KeyDerivation1.java:109:65:109:86 | +| jca/KeyDerivation1.java:109:65:109:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:109:65:109:86 | jca/KeyDerivation1.java:109:65:109:86 | +| jca/KeyDerivation1.java:109:65:109:86 | HashAlgorithm | DigestSize | 256 | jca/KeyDerivation1.java:109:65:109:86 | jca/KeyDerivation1.java:109:65:109:86 | +| jca/KeyDerivation1.java:109:65:109:86 | HashAlgorithm | Name | SHA2 | jca/KeyDerivation1.java:109:65:109:86 | jca/KeyDerivation1.java:109:65:109:86 | +| jca/KeyDerivation1.java:109:65:109:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:109:65:109:86 | jca/KeyDerivation1.java:109:65:109:86 | +| jca/KeyDerivation1.java:109:65:109:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:109:65:109:86 | jca/KeyDerivation1.java:109:65:109:86 | +| jca/KeyDerivation1.java:109:65:109:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:109:65:109:86 | jca/KeyDerivation1.java:109:65:109:86 | +| jca/KeyDerivation1.java:110:22:110:49 | Key | KeyType | Symmetric | jca/KeyDerivation1.java:110:22:110:49 | jca/KeyDerivation1.java:110:22:110:49 | +| jca/KeyDerivation1.java:110:22:110:49 | KeyDerivation | Iterations | Constant:1_000_000 | jca/KeyDerivation1.java:108:72:108:80 | jca/KeyDerivation1.java:108:72:108:80 | +| jca/KeyDerivation1.java:110:22:110:49 | KeyDerivation | KeySize | Constant:256 | jca/KeyDerivation1.java:108:83:108:85 | jca/KeyDerivation1.java:108:83:108:85 | +| jca/KeyDerivation1.java:120:32:120:46 | Parameter | Description | password | jca/KeyDerivation1.java:120:32:120:46 | jca/KeyDerivation1.java:120:32:120:46 | +| jca/KeyDerivation1.java:122:72:122:76 | Constant | Description | 80000 | jca/KeyDerivation1.java:122:72:122:76 | jca/KeyDerivation1.java:122:72:122:76 | +| jca/KeyDerivation1.java:122:79:122:81 | Constant | Description | 256 | jca/KeyDerivation1.java:122:79:122:81 | jca/KeyDerivation1.java:122:79:122:81 | +| jca/KeyDerivation1.java:123:65:123:84 | HMACAlgorithm | Name | HMAC | jca/KeyDerivation1.java:123:65:123:84 | jca/KeyDerivation1.java:123:65:123:84 | +| jca/KeyDerivation1.java:123:65:123:84 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA1 | jca/KeyDerivation1.java:123:65:123:84 | jca/KeyDerivation1.java:123:65:123:84 | +| jca/KeyDerivation1.java:123:65:123:84 | HashAlgorithm | DigestSize | 160 | jca/KeyDerivation1.java:123:65:123:84 | jca/KeyDerivation1.java:123:65:123:84 | +| jca/KeyDerivation1.java:123:65:123:84 | HashAlgorithm | Name | SHA1 | jca/KeyDerivation1.java:123:65:123:84 | jca/KeyDerivation1.java:123:65:123:84 | +| jca/KeyDerivation1.java:123:65:123:84 | HashAlgorithm | RawName | PBKDF2WithHmacSHA1 | jca/KeyDerivation1.java:123:65:123:84 | jca/KeyDerivation1.java:123:65:123:84 | +| jca/KeyDerivation1.java:123:65:123:84 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA1 | jca/KeyDerivation1.java:123:65:123:84 | jca/KeyDerivation1.java:123:65:123:84 | +| jca/KeyDerivation1.java:123:65:123:84 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA1 | jca/KeyDerivation1.java:123:65:123:84 | jca/KeyDerivation1.java:123:65:123:84 | +| jca/KeyDerivation1.java:124:22:124:49 | Key | KeyType | Symmetric | jca/KeyDerivation1.java:124:22:124:49 | jca/KeyDerivation1.java:124:22:124:49 | +| jca/KeyDerivation1.java:124:22:124:49 | KeyDerivation | Iterations | Constant:80000 | jca/KeyDerivation1.java:122:72:122:76 | jca/KeyDerivation1.java:122:72:122:76 | +| jca/KeyDerivation1.java:124:22:124:49 | KeyDerivation | KeySize | Constant:256 | jca/KeyDerivation1.java:122:79:122:81 | jca/KeyDerivation1.java:122:79:122:81 | +| jca/KeyDerivation1.java:134:34:134:48 | Parameter | Description | password | jca/KeyDerivation1.java:134:34:134:48 | jca/KeyDerivation1.java:134:34:134:48 | +| jca/KeyDerivation1.java:136:72:136:77 | Constant | Description | 160000 | jca/KeyDerivation1.java:136:72:136:77 | jca/KeyDerivation1.java:136:72:136:77 | +| jca/KeyDerivation1.java:136:80:136:82 | Constant | Description | 256 | jca/KeyDerivation1.java:136:80:136:82 | jca/KeyDerivation1.java:136:80:136:82 | +| jca/KeyDerivation1.java:137:65:137:86 | HMACAlgorithm | Name | HMAC | jca/KeyDerivation1.java:137:65:137:86 | jca/KeyDerivation1.java:137:65:137:86 | +| jca/KeyDerivation1.java:137:65:137:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA512 | jca/KeyDerivation1.java:137:65:137:86 | jca/KeyDerivation1.java:137:65:137:86 | +| jca/KeyDerivation1.java:137:65:137:86 | HashAlgorithm | DigestSize | 512 | jca/KeyDerivation1.java:137:65:137:86 | jca/KeyDerivation1.java:137:65:137:86 | +| jca/KeyDerivation1.java:137:65:137:86 | HashAlgorithm | Name | SHA2 | jca/KeyDerivation1.java:137:65:137:86 | jca/KeyDerivation1.java:137:65:137:86 | +| jca/KeyDerivation1.java:137:65:137:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA512 | jca/KeyDerivation1.java:137:65:137:86 | jca/KeyDerivation1.java:137:65:137:86 | +| jca/KeyDerivation1.java:137:65:137:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA512 | jca/KeyDerivation1.java:137:65:137:86 | jca/KeyDerivation1.java:137:65:137:86 | +| jca/KeyDerivation1.java:137:65:137:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA512 | jca/KeyDerivation1.java:137:65:137:86 | jca/KeyDerivation1.java:137:65:137:86 | +| jca/KeyDerivation1.java:138:22:138:49 | Key | KeyType | Symmetric | jca/KeyDerivation1.java:138:22:138:49 | jca/KeyDerivation1.java:138:22:138:49 | +| jca/KeyDerivation1.java:138:22:138:49 | KeyDerivation | Iterations | Constant:160000 | jca/KeyDerivation1.java:136:72:136:77 | jca/KeyDerivation1.java:136:72:136:77 | +| jca/KeyDerivation1.java:138:22:138:49 | KeyDerivation | KeySize | Constant:256 | jca/KeyDerivation1.java:136:80:136:82 | jca/KeyDerivation1.java:136:80:136:82 | +| jca/KeyDerivation1.java:154:28:154:42 | Parameter | Description | password | jca/KeyDerivation1.java:154:28:154:42 | jca/KeyDerivation1.java:154:28:154:42 | +| jca/KeyDerivation1.java:157:72:157:75 | Constant | Description | 1024 | jca/KeyDerivation1.java:157:72:157:75 | jca/KeyDerivation1.java:157:72:157:75 | +| jca/KeyDerivation1.java:157:78:157:80 | Constant | Description | 128 | jca/KeyDerivation1.java:157:78:157:80 | jca/KeyDerivation1.java:157:78:157:80 | +| jca/KeyDerivation1.java:158:65:158:72 | Constant | Description | "SCRYPT" | jca/KeyDerivation1.java:158:65:158:72 | jca/KeyDerivation1.java:158:65:158:72 | +| jca/KeyDerivation1.java:159:22:159:49 | Key | KeyType | Symmetric | jca/KeyDerivation1.java:159:22:159:49 | jca/KeyDerivation1.java:159:22:159:49 | +| jca/KeyDerivation1.java:159:22:159:49 | KeyDerivation | Iterations | Constant:1024 | jca/KeyDerivation1.java:157:72:157:75 | jca/KeyDerivation1.java:157:72:157:75 | +| jca/KeyDerivation1.java:159:22:159:49 | KeyDerivation | KeySize | Constant:128 | jca/KeyDerivation1.java:157:78:157:80 | jca/KeyDerivation1.java:157:78:157:80 | +| jca/KeyDerivation1.java:169:30:169:44 | Parameter | Description | password | jca/KeyDerivation1.java:169:30:169:44 | jca/KeyDerivation1.java:169:30:169:44 | +| jca/KeyDerivation1.java:172:72:172:76 | Constant | Description | 16384 | jca/KeyDerivation1.java:172:72:172:76 | jca/KeyDerivation1.java:172:72:172:76 | +| jca/KeyDerivation1.java:172:79:172:81 | Constant | Description | 256 | jca/KeyDerivation1.java:172:79:172:81 | jca/KeyDerivation1.java:172:79:172:81 | +| jca/KeyDerivation1.java:173:65:173:72 | Constant | Description | "SCRYPT" | jca/KeyDerivation1.java:173:65:173:72 | jca/KeyDerivation1.java:173:65:173:72 | +| jca/KeyDerivation1.java:174:22:174:49 | Key | KeyType | Symmetric | jca/KeyDerivation1.java:174:22:174:49 | jca/KeyDerivation1.java:174:22:174:49 | +| jca/KeyDerivation1.java:174:22:174:49 | KeyDerivation | Iterations | Constant:16384 | jca/KeyDerivation1.java:172:72:172:76 | jca/KeyDerivation1.java:172:72:172:76 | +| jca/KeyDerivation1.java:174:22:174:49 | KeyDerivation | KeySize | Constant:256 | jca/KeyDerivation1.java:172:79:172:81 | jca/KeyDerivation1.java:172:79:172:81 | +| jca/KeyDerivation1.java:242:45:242:56 | Parameter | Description | input | jca/KeyDerivation1.java:242:45:242:56 | jca/KeyDerivation1.java:242:45:242:56 | +| jca/KeyDerivation1.java:243:58:243:66 | HashAlgorithm | DigestSize | 256 | jca/KeyDerivation1.java:243:58:243:66 | jca/KeyDerivation1.java:243:58:243:66 | +| jca/KeyDerivation1.java:243:58:243:66 | HashAlgorithm | Name | SHA2 | jca/KeyDerivation1.java:243:58:243:66 | jca/KeyDerivation1.java:243:58:243:66 | +| jca/KeyDerivation1.java:243:58:243:66 | HashAlgorithm | RawName | SHA-256 | jca/KeyDerivation1.java:243:58:243:66 | jca/KeyDerivation1.java:243:58:243:66 | +| jca/KeyDerivation1.java:249:70:249:88 | KeyOperationAlgorithm | Name | AES | jca/KeyDerivation1.java:249:70:249:88 | jca/KeyDerivation1.java:249:70:249:88 | +| jca/KeyDerivation1.java:249:70:249:88 | KeyOperationAlgorithm | RawName | AES/ECB/NoPadding | jca/KeyDerivation1.java:249:70:249:88 | jca/KeyDerivation1.java:249:70:249:88 | +| jca/KeyDerivation1.java:249:70:249:88 | KeyOperationAlgorithm | Structure | Block | jca/KeyDerivation1.java:249:70:249:88 | jca/KeyDerivation1.java:249:70:249:88 | +| jca/KeyDerivation1.java:249:70:249:88 | ModeOfOperation | Name | ECB | jca/KeyDerivation1.java:249:70:249:88 | jca/KeyDerivation1.java:249:70:249:88 | +| jca/KeyDerivation1.java:249:70:249:88 | ModeOfOperation | RawName | ECB | jca/KeyDerivation1.java:249:70:249:88 | jca/KeyDerivation1.java:249:70:249:88 | +| jca/KeyDerivation1.java:249:70:249:88 | PaddingAlgorithm | Name | UnknownPadding | jca/KeyDerivation1.java:249:70:249:88 | jca/KeyDerivation1.java:249:70:249:88 | +| jca/KeyDerivation1.java:249:70:249:88 | PaddingAlgorithm | RawName | NoPadding | jca/KeyDerivation1.java:249:70:249:88 | jca/KeyDerivation1.java:249:70:249:88 | +| jca/KeyDerivation1.java:250:55:250:57 | Key | KeyType | Unknown | jca/KeyDerivation1.java:250:55:250:57 | jca/KeyDerivation1.java:250:55:250:57 | +| jca/KeyDerivation1.java:251:29:251:74 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/KeyDerivation1.java:251:29:251:74 | jca/KeyDerivation1.java:251:29:251:74 | +| jca/KeyDerivation1.java:251:44:251:62 | Constant | Description | "SampleData16Bytes" | jca/KeyDerivation1.java:251:44:251:62 | jca/KeyDerivation1.java:251:44:251:62 | +| jca/KeyDerivation1.java:269:32:269:41 | Parameter | Description | ikm | jca/KeyDerivation1.java:269:32:269:41 | jca/KeyDerivation1.java:269:32:269:41 | +| jca/KeyDerivation1.java:283:43:283:57 | Parameter | Description | password | jca/KeyDerivation1.java:283:43:283:57 | jca/KeyDerivation1.java:283:43:283:57 | +| jca/KeyDerivation1.java:283:60:283:78 | Parameter | Description | sharedSecret | jca/KeyDerivation1.java:283:60:283:78 | jca/KeyDerivation1.java:283:60:283:78 | +| jca/KeyDerivation1.java:302:37:302:51 | Parameter | Description | password | jca/KeyDerivation1.java:302:37:302:51 | jca/KeyDerivation1.java:302:37:302:51 | +| jca/KeyDerivation1.java:309:25:309:76 | LocalData | Description | getProperty(...) | jca/KeyDerivation1.java:309:25:309:76 | jca/KeyDerivation1.java:309:25:309:76 | +| jca/KeyDerivation1.java:309:54:309:75 | HMACAlgorithm | Name | HMAC | jca/KeyDerivation1.java:309:54:309:75 | jca/KeyDerivation1.java:309:54:309:75 | +| jca/KeyDerivation1.java:309:54:309:75 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:309:54:309:75 | jca/KeyDerivation1.java:309:54:309:75 | +| jca/KeyDerivation1.java:309:54:309:75 | HashAlgorithm | DigestSize | 256 | jca/KeyDerivation1.java:309:54:309:75 | jca/KeyDerivation1.java:309:54:309:75 | +| jca/KeyDerivation1.java:309:54:309:75 | HashAlgorithm | Name | SHA2 | jca/KeyDerivation1.java:309:54:309:75 | jca/KeyDerivation1.java:309:54:309:75 | +| jca/KeyDerivation1.java:309:54:309:75 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:309:54:309:75 | jca/KeyDerivation1.java:309:54:309:75 | +| jca/KeyDerivation1.java:309:54:309:75 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:309:54:309:75 | jca/KeyDerivation1.java:309:54:309:75 | +| jca/KeyDerivation1.java:309:54:309:75 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:309:54:309:75 | jca/KeyDerivation1.java:309:54:309:75 | +| jca/KeyDerivation1.java:310:43:310:86 | LocalData | Description | getProperty(...) | jca/KeyDerivation1.java:310:43:310:86 | jca/KeyDerivation1.java:310:43:310:86 | +| jca/KeyDerivation1.java:311:40:311:78 | LocalData | Description | getProperty(...) | jca/KeyDerivation1.java:311:40:311:78 | jca/KeyDerivation1.java:311:40:311:78 | +| jca/KeyDerivation1.java:316:26:316:53 | Key | KeyType | Symmetric | jca/KeyDerivation1.java:316:26:316:53 | jca/KeyDerivation1.java:316:26:316:53 | +| jca/KeyDerivation1.java:316:26:316:53 | KeyDerivation | Iterations | LocalData:getProperty(...) | jca/KeyDerivation1.java:310:43:310:86 | jca/KeyDerivation1.java:310:43:310:86 | +| jca/KeyDerivation1.java:316:26:316:53 | KeyDerivation | KeySize | LocalData:getProperty(...) | jca/KeyDerivation1.java:311:40:311:78 | jca/KeyDerivation1.java:311:40:311:78 | +| jca/KeyDerivation1.java:333:72:333:76 | Constant | Description | 10000 | jca/KeyDerivation1.java:333:72:333:76 | jca/KeyDerivation1.java:333:72:333:76 | +| jca/KeyDerivation1.java:333:79:333:81 | Constant | Description | 256 | jca/KeyDerivation1.java:333:79:333:81 | jca/KeyDerivation1.java:333:79:333:81 | +| jca/KeyDerivation1.java:334:65:334:86 | HMACAlgorithm | Name | HMAC | jca/KeyDerivation1.java:334:65:334:86 | jca/KeyDerivation1.java:334:65:334:86 | +| jca/KeyDerivation1.java:334:65:334:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:334:65:334:86 | jca/KeyDerivation1.java:334:65:334:86 | +| jca/KeyDerivation1.java:334:65:334:86 | HashAlgorithm | DigestSize | 256 | jca/KeyDerivation1.java:334:65:334:86 | jca/KeyDerivation1.java:334:65:334:86 | +| jca/KeyDerivation1.java:334:65:334:86 | HashAlgorithm | Name | SHA2 | jca/KeyDerivation1.java:334:65:334:86 | jca/KeyDerivation1.java:334:65:334:86 | +| jca/KeyDerivation1.java:334:65:334:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:334:65:334:86 | jca/KeyDerivation1.java:334:65:334:86 | +| jca/KeyDerivation1.java:334:65:334:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:334:65:334:86 | jca/KeyDerivation1.java:334:65:334:86 | +| jca/KeyDerivation1.java:334:65:334:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/KeyDerivation1.java:334:65:334:86 | jca/KeyDerivation1.java:334:65:334:86 | +| jca/KeyDerivation1.java:335:16:335:43 | Key | KeyType | Symmetric | jca/KeyDerivation1.java:335:16:335:43 | jca/KeyDerivation1.java:335:16:335:43 | +| jca/KeyDerivation1.java:335:16:335:43 | KeyDerivation | Iterations | Constant:10000 | jca/KeyDerivation1.java:333:72:333:76 | jca/KeyDerivation1.java:333:72:333:76 | +| jca/KeyDerivation1.java:335:16:335:43 | KeyDerivation | KeySize | Constant:256 | jca/KeyDerivation1.java:333:79:333:81 | jca/KeyDerivation1.java:333:79:333:81 | +| jca/KeyDerivation1.java:345:36:345:47 | KeyOperationAlgorithm | Name | HMAC | jca/KeyDerivation1.java:345:36:345:47 | jca/KeyDerivation1.java:345:36:345:47 | +| jca/KeyDerivation1.java:345:36:345:47 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/KeyDerivation1.java:345:36:345:47 | jca/KeyDerivation1.java:345:36:345:47 | +| jca/KeyDerivation1.java:347:19:347:27 | Key | KeyType | Unknown | jca/KeyDerivation1.java:347:19:347:27 | jca/KeyDerivation1.java:347:19:347:27 | +| jca/KeyDerivation1.java:348:22:348:38 | MACOperation | KeyOperationSubtype | Mac | jca/KeyDerivation1.java:348:22:348:38 | jca/KeyDerivation1.java:348:22:348:38 | +| jca/KeyDerivation1.java:352:19:352:54 | Key | KeyType | Unknown | jca/KeyDerivation1.java:352:19:352:54 | jca/KeyDerivation1.java:352:19:352:54 | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | KeyOperationSubtype | Mac | jca/KeyDerivation1.java:353:22:353:62 | jca/KeyDerivation1.java:353:22:353:62 | +| jca/KeyDerivation1.java:353:35:353:50 | Constant | Description | "hkdf-expansion" | jca/KeyDerivation1.java:353:35:353:50 | jca/KeyDerivation1.java:353:35:353:50 | +| jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | Description | nextBytes | jca/KeyDerivation1.java:365:9:365:42 | jca/KeyDerivation1.java:365:9:365:42 | +| jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/KeyDerivation1.java:365:38:365:41 | jca/KeyDerivation1.java:365:38:365:41 | +| jca/KeyEncapsulation.java:60:56:60:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/KeyEncapsulation.java:61:21:61:23 | jca/KeyEncapsulation.java:61:21:61:23 | +| jca/KeyEncapsulation.java:60:56:60:60 | KeyOperationAlgorithm | Name | AES | jca/KeyEncapsulation.java:60:56:60:60 | jca/KeyEncapsulation.java:60:56:60:60 | +| jca/KeyEncapsulation.java:60:56:60:60 | KeyOperationAlgorithm | RawName | AES | jca/KeyEncapsulation.java:60:56:60:60 | jca/KeyEncapsulation.java:60:56:60:60 | +| jca/KeyEncapsulation.java:60:56:60:60 | KeyOperationAlgorithm | Structure | Block | jca/KeyEncapsulation.java:60:56:60:60 | jca/KeyEncapsulation.java:60:56:60:60 | +| jca/KeyEncapsulation.java:61:21:61:23 | Constant | Description | 256 | jca/KeyEncapsulation.java:61:21:61:23 | jca/KeyEncapsulation.java:61:21:61:23 | +| jca/KeyEncapsulation.java:62:28:62:47 | Key | KeyType | Symmetric | jca/KeyEncapsulation.java:62:28:62:47 | jca/KeyEncapsulation.java:62:28:62:47 | +| jca/KeyEncapsulation.java:67:47:67:85 | HashAlgorithm | DigestSize | 256 | jca/KeyEncapsulation.java:67:47:67:85 | jca/KeyEncapsulation.java:67:47:67:85 | +| jca/KeyEncapsulation.java:67:47:67:85 | HashAlgorithm | Name | SHA2 | jca/KeyEncapsulation.java:67:47:67:85 | jca/KeyEncapsulation.java:67:47:67:85 | +| jca/KeyEncapsulation.java:67:47:67:85 | HashAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/KeyEncapsulation.java:67:47:67:85 | jca/KeyEncapsulation.java:67:47:67:85 | +| jca/KeyEncapsulation.java:67:47:67:85 | KeyOperationAlgorithm | Name | RSA | jca/KeyEncapsulation.java:67:47:67:85 | jca/KeyEncapsulation.java:67:47:67:85 | +| jca/KeyEncapsulation.java:67:47:67:85 | KeyOperationAlgorithm | RawName | RSA/ECB/OAEPWithSHA-256AndMGF1Padding | jca/KeyEncapsulation.java:67:47:67:85 | jca/KeyEncapsulation.java:67:47:67:85 | +| jca/KeyEncapsulation.java:67:47:67:85 | ModeOfOperation | Name | ECB | jca/KeyEncapsulation.java:67:47:67:85 | jca/KeyEncapsulation.java:67:47:67:85 | +| jca/KeyEncapsulation.java:67:47:67:85 | ModeOfOperation | RawName | ECB | jca/KeyEncapsulation.java:67:47:67:85 | jca/KeyEncapsulation.java:67:47:67:85 | +| jca/KeyEncapsulation.java:67:47:67:85 | PaddingAlgorithm | Name | OAEP | jca/KeyEncapsulation.java:67:47:67:85 | jca/KeyEncapsulation.java:67:47:67:85 | +| jca/KeyEncapsulation.java:67:47:67:85 | PaddingAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/KeyEncapsulation.java:67:47:67:85 | jca/KeyEncapsulation.java:67:47:67:85 | +| jca/KeyEncapsulation.java:68:45:68:50 | Key | KeyType | Unknown | jca/KeyEncapsulation.java:68:45:68:50 | jca/KeyEncapsulation.java:68:45:68:50 | +| jca/KeyEncapsulation.java:69:29:69:66 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/KeyEncapsulation.java:69:29:69:66 | jca/KeyEncapsulation.java:69:29:69:66 | +| jca/KeyEncapsulation.java:73:47:73:65 | KeyOperationAlgorithm | Name | AES | jca/KeyEncapsulation.java:73:47:73:65 | jca/KeyEncapsulation.java:73:47:73:65 | +| jca/KeyEncapsulation.java:73:47:73:65 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/KeyEncapsulation.java:73:47:73:65 | jca/KeyEncapsulation.java:73:47:73:65 | +| jca/KeyEncapsulation.java:73:47:73:65 | KeyOperationAlgorithm | Structure | Block | jca/KeyEncapsulation.java:73:47:73:65 | jca/KeyEncapsulation.java:73:47:73:65 | +| jca/KeyEncapsulation.java:73:47:73:65 | ModeOfOperation | Name | GCM | jca/KeyEncapsulation.java:73:47:73:65 | jca/KeyEncapsulation.java:73:47:73:65 | +| jca/KeyEncapsulation.java:73:47:73:65 | ModeOfOperation | RawName | GCM | jca/KeyEncapsulation.java:73:47:73:65 | jca/KeyEncapsulation.java:73:47:73:65 | +| jca/KeyEncapsulation.java:73:47:73:65 | PaddingAlgorithm | Name | UnknownPadding | jca/KeyEncapsulation.java:73:47:73:65 | jca/KeyEncapsulation.java:73:47:73:65 | +| jca/KeyEncapsulation.java:73:47:73:65 | PaddingAlgorithm | RawName | NoPadding | jca/KeyEncapsulation.java:73:47:73:65 | jca/KeyEncapsulation.java:73:47:73:65 | +| jca/KeyEncapsulation.java:75:9:75:40 | RandomNumberGeneration | Description | nextBytes | jca/KeyEncapsulation.java:75:9:75:40 | jca/KeyEncapsulation.java:75:9:75:40 | +| jca/KeyEncapsulation.java:75:38:75:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/KeyEncapsulation.java:75:38:75:39 | jca/KeyEncapsulation.java:75:38:75:39 | +| jca/KeyEncapsulation.java:77:45:77:50 | Key | KeyType | Unknown | jca/KeyEncapsulation.java:77:45:77:50 | jca/KeyEncapsulation.java:77:45:77:50 | +| jca/KeyEncapsulation.java:78:29:78:80 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/KeyEncapsulation.java:78:29:78:80 | jca/KeyEncapsulation.java:78:29:78:80 | +| jca/KeyEncapsulation.java:78:47:78:68 | Constant | Description | "KEM-based encryption" | jca/KeyEncapsulation.java:78:47:78:68 | jca/KeyEncapsulation.java:78:47:78:68 | +| jca/KeyEncapsulation.java:91:37:91:54 | Parameter | Description | rsaPriv | jca/KeyEncapsulation.java:91:37:91:54 | jca/KeyEncapsulation.java:91:37:91:54 | +| jca/KeyEncapsulation.java:91:57:91:73 | Parameter | Description | wrappedKey | jca/KeyEncapsulation.java:91:57:91:73 | jca/KeyEncapsulation.java:91:57:91:73 | +| jca/KeyEncapsulation.java:92:47:92:85 | HashAlgorithm | DigestSize | 256 | jca/KeyEncapsulation.java:92:47:92:85 | jca/KeyEncapsulation.java:92:47:92:85 | +| jca/KeyEncapsulation.java:92:47:92:85 | HashAlgorithm | Name | SHA2 | jca/KeyEncapsulation.java:92:47:92:85 | jca/KeyEncapsulation.java:92:47:92:85 | +| jca/KeyEncapsulation.java:92:47:92:85 | HashAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/KeyEncapsulation.java:92:47:92:85 | jca/KeyEncapsulation.java:92:47:92:85 | +| jca/KeyEncapsulation.java:92:47:92:85 | KeyOperationAlgorithm | Name | RSA | jca/KeyEncapsulation.java:92:47:92:85 | jca/KeyEncapsulation.java:92:47:92:85 | +| jca/KeyEncapsulation.java:92:47:92:85 | KeyOperationAlgorithm | RawName | RSA/ECB/OAEPWithSHA-256AndMGF1Padding | jca/KeyEncapsulation.java:92:47:92:85 | jca/KeyEncapsulation.java:92:47:92:85 | +| jca/KeyEncapsulation.java:92:47:92:85 | ModeOfOperation | Name | ECB | jca/KeyEncapsulation.java:92:47:92:85 | jca/KeyEncapsulation.java:92:47:92:85 | +| jca/KeyEncapsulation.java:92:47:92:85 | ModeOfOperation | RawName | ECB | jca/KeyEncapsulation.java:92:47:92:85 | jca/KeyEncapsulation.java:92:47:92:85 | +| jca/KeyEncapsulation.java:92:47:92:85 | PaddingAlgorithm | Name | OAEP | jca/KeyEncapsulation.java:92:47:92:85 | jca/KeyEncapsulation.java:92:47:92:85 | +| jca/KeyEncapsulation.java:92:47:92:85 | PaddingAlgorithm | RawName | OAEPWithSHA-256AndMGF1Padding | jca/KeyEncapsulation.java:92:47:92:85 | jca/KeyEncapsulation.java:92:47:92:85 | +| jca/KeyEncapsulation.java:93:45:93:51 | Key | KeyType | Unknown | jca/KeyEncapsulation.java:93:45:93:51 | jca/KeyEncapsulation.java:93:45:93:51 | +| jca/KeyEncapsulation.java:94:30:94:58 | DecryptOperation | KeyOperationSubtype | Decrypt | jca/KeyEncapsulation.java:94:30:94:58 | jca/KeyEncapsulation.java:94:30:94:58 | +| jca/KeyEncapsulation.java:117:47:117:57 | EllipticCurve | KeySize | 256 | jca/KeyEncapsulation.java:117:47:117:57 | jca/KeyEncapsulation.java:117:47:117:57 | +| jca/KeyEncapsulation.java:117:47:117:57 | EllipticCurve | Name | secp256r1 | jca/KeyEncapsulation.java:117:47:117:57 | jca/KeyEncapsulation.java:117:47:117:57 | +| jca/KeyEncapsulation.java:117:47:117:57 | EllipticCurve | ParsedName | secp256r1 | jca/KeyEncapsulation.java:117:47:117:57 | jca/KeyEncapsulation.java:117:47:117:57 | +| jca/KeyEncapsulation.java:117:47:117:57 | EllipticCurve | RawName | secp256r1 | jca/KeyEncapsulation.java:117:47:117:57 | jca/KeyEncapsulation.java:117:47:117:57 | +| jca/KeyEncapsulation.java:118:31:118:51 | Key | KeyType | Asymmetric | jca/KeyEncapsulation.java:118:31:118:51 | jca/KeyEncapsulation.java:118:31:118:51 | +| jca/KeyEncapsulation.java:121:52:121:57 | KeyAgreementAlgorithm | Name | ECDH | jca/KeyEncapsulation.java:121:52:121:57 | jca/KeyEncapsulation.java:121:52:121:57 | +| jca/KeyEncapsulation.java:121:52:121:57 | KeyAgreementAlgorithm | RawName | ECDH | jca/KeyEncapsulation.java:121:52:121:57 | jca/KeyEncapsulation.java:121:52:121:57 | +| jca/KeyEncapsulation.java:122:17:122:40 | Key | KeyType | Unknown | jca/KeyEncapsulation.java:122:17:122:40 | jca/KeyEncapsulation.java:122:17:122:40 | +| jca/KeyEncapsulation.java:123:20:123:24 | Key | KeyType | Unknown | jca/KeyEncapsulation.java:123:20:123:24 | jca/KeyEncapsulation.java:123:20:123:24 | +| jca/KeyEncapsulation.java:133:47:133:65 | KeyOperationAlgorithm | Name | AES | jca/KeyEncapsulation.java:133:47:133:65 | jca/KeyEncapsulation.java:133:47:133:65 | +| jca/KeyEncapsulation.java:133:47:133:65 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/KeyEncapsulation.java:133:47:133:65 | jca/KeyEncapsulation.java:133:47:133:65 | +| jca/KeyEncapsulation.java:133:47:133:65 | KeyOperationAlgorithm | Structure | Block | jca/KeyEncapsulation.java:133:47:133:65 | jca/KeyEncapsulation.java:133:47:133:65 | +| jca/KeyEncapsulation.java:133:47:133:65 | ModeOfOperation | Name | GCM | jca/KeyEncapsulation.java:133:47:133:65 | jca/KeyEncapsulation.java:133:47:133:65 | +| jca/KeyEncapsulation.java:133:47:133:65 | ModeOfOperation | RawName | GCM | jca/KeyEncapsulation.java:133:47:133:65 | jca/KeyEncapsulation.java:133:47:133:65 | +| jca/KeyEncapsulation.java:133:47:133:65 | PaddingAlgorithm | Name | UnknownPadding | jca/KeyEncapsulation.java:133:47:133:65 | jca/KeyEncapsulation.java:133:47:133:65 | +| jca/KeyEncapsulation.java:133:47:133:65 | PaddingAlgorithm | RawName | NoPadding | jca/KeyEncapsulation.java:133:47:133:65 | jca/KeyEncapsulation.java:133:47:133:65 | +| jca/KeyEncapsulation.java:135:9:135:40 | RandomNumberGeneration | Description | nextBytes | jca/KeyEncapsulation.java:135:9:135:40 | jca/KeyEncapsulation.java:135:9:135:40 | +| jca/KeyEncapsulation.java:135:38:135:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/KeyEncapsulation.java:135:38:135:39 | jca/KeyEncapsulation.java:135:38:135:39 | +| jca/KeyEncapsulation.java:136:45:136:50 | Key | KeyType | Unknown | jca/KeyEncapsulation.java:136:45:136:50 | jca/KeyEncapsulation.java:136:45:136:50 | +| jca/KeyEncapsulation.java:137:29:137:73 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/KeyEncapsulation.java:137:29:137:73 | jca/KeyEncapsulation.java:137:29:137:73 | +| jca/KeyEncapsulation.java:137:47:137:61 | Constant | Description | "ECIES message" | jca/KeyEncapsulation.java:137:47:137:61 | jca/KeyEncapsulation.java:137:47:137:61 | +| jca/KeyEncapsulation.java:186:47:186:57 | EllipticCurve | KeySize | 256 | jca/KeyEncapsulation.java:186:47:186:57 | jca/KeyEncapsulation.java:186:47:186:57 | +| jca/KeyEncapsulation.java:186:47:186:57 | EllipticCurve | Name | secp256r1 | jca/KeyEncapsulation.java:186:47:186:57 | jca/KeyEncapsulation.java:186:47:186:57 | +| jca/KeyEncapsulation.java:186:47:186:57 | EllipticCurve | ParsedName | secp256r1 | jca/KeyEncapsulation.java:186:47:186:57 | jca/KeyEncapsulation.java:186:47:186:57 | +| jca/KeyEncapsulation.java:186:47:186:57 | EllipticCurve | RawName | secp256r1 | jca/KeyEncapsulation.java:186:47:186:57 | jca/KeyEncapsulation.java:186:47:186:57 | +| jca/KeyEncapsulation.java:187:31:187:51 | Key | KeyType | Asymmetric | jca/KeyEncapsulation.java:187:31:187:51 | jca/KeyEncapsulation.java:187:31:187:51 | +| jca/KeyEncapsulation.java:188:52:188:57 | KeyAgreementAlgorithm | Name | ECDH | jca/KeyEncapsulation.java:188:52:188:57 | jca/KeyEncapsulation.java:188:52:188:57 | +| jca/KeyEncapsulation.java:188:52:188:57 | KeyAgreementAlgorithm | RawName | ECDH | jca/KeyEncapsulation.java:188:52:188:57 | jca/KeyEncapsulation.java:188:52:188:57 | +| jca/KeyEncapsulation.java:189:17:189:40 | Key | KeyType | Unknown | jca/KeyEncapsulation.java:189:17:189:40 | jca/KeyEncapsulation.java:189:17:189:40 | +| jca/KeyEncapsulation.java:190:20:190:34 | Key | KeyType | Unknown | jca/KeyEncapsulation.java:190:20:190:34 | jca/KeyEncapsulation.java:190:20:190:34 | +| jca/KeyEncapsulation.java:207:64:207:68 | KeyOperationAlgorithm | KeySize | Constant:2048 | jca/KeyEncapsulation.java:208:27:208:30 | jca/KeyEncapsulation.java:208:27:208:30 | +| jca/KeyEncapsulation.java:207:64:207:68 | KeyOperationAlgorithm | Name | RSA | jca/KeyEncapsulation.java:207:64:207:68 | jca/KeyEncapsulation.java:207:64:207:68 | +| jca/KeyEncapsulation.java:207:64:207:68 | KeyOperationAlgorithm | RawName | RSA | jca/KeyEncapsulation.java:207:64:207:68 | jca/KeyEncapsulation.java:207:64:207:68 | +| jca/KeyEncapsulation.java:208:27:208:30 | Constant | Description | 2048 | jca/KeyEncapsulation.java:208:27:208:30 | jca/KeyEncapsulation.java:208:27:208:30 | +| jca/KeyEncapsulation.java:209:25:209:48 | Key | KeyType | Asymmetric | jca/KeyEncapsulation.java:209:25:209:48 | jca/KeyEncapsulation.java:209:25:209:48 | +| jca/KeyEncapsulation.java:214:49:214:59 | EllipticCurve | KeySize | 256 | jca/KeyEncapsulation.java:214:49:214:59 | jca/KeyEncapsulation.java:214:49:214:59 | +| jca/KeyEncapsulation.java:214:49:214:59 | EllipticCurve | Name | secp256r1 | jca/KeyEncapsulation.java:214:49:214:59 | jca/KeyEncapsulation.java:214:49:214:59 | +| jca/KeyEncapsulation.java:214:49:214:59 | EllipticCurve | ParsedName | secp256r1 | jca/KeyEncapsulation.java:214:49:214:59 | jca/KeyEncapsulation.java:214:49:214:59 | +| jca/KeyEncapsulation.java:214:49:214:59 | EllipticCurve | RawName | secp256r1 | jca/KeyEncapsulation.java:214:49:214:59 | jca/KeyEncapsulation.java:214:49:214:59 | +| jca/KeyEncapsulation.java:215:24:215:46 | Key | KeyType | Asymmetric | jca/KeyEncapsulation.java:215:24:215:46 | jca/KeyEncapsulation.java:215:24:215:46 | +| jca/KeyEncapsulation.java:226:31:226:53 | Key | KeyType | Asymmetric | jca/KeyEncapsulation.java:226:31:226:53 | jca/KeyEncapsulation.java:226:31:226:53 | +| jca/KeyExchange.java:52:63:52:66 | KeyAgreementAlgorithm | Name | DH | jca/KeyExchange.java:52:63:52:66 | jca/KeyExchange.java:52:63:52:66 | +| jca/KeyExchange.java:52:63:52:66 | KeyAgreementAlgorithm | RawName | DH | jca/KeyExchange.java:52:63:52:66 | jca/KeyExchange.java:52:63:52:66 | +| jca/KeyExchange.java:53:26:53:29 | Constant | Description | 2048 | jca/KeyExchange.java:53:26:53:29 | jca/KeyExchange.java:53:26:53:29 | +| jca/KeyExchange.java:54:16:54:38 | Key | KeyType | Asymmetric | jca/KeyExchange.java:54:16:54:38 | jca/KeyExchange.java:54:16:54:38 | +| jca/KeyExchange.java:67:63:67:66 | KeyAgreementAlgorithm | Name | DH | jca/KeyExchange.java:67:63:67:66 | jca/KeyExchange.java:67:63:67:66 | +| jca/KeyExchange.java:67:63:67:66 | KeyAgreementAlgorithm | RawName | DH | jca/KeyExchange.java:67:63:67:66 | jca/KeyExchange.java:67:63:67:66 | +| jca/KeyExchange.java:69:26:69:28 | Constant | Description | 512 | jca/KeyExchange.java:69:26:69:28 | jca/KeyExchange.java:69:26:69:28 | +| jca/KeyExchange.java:70:16:70:38 | Key | KeyType | Asymmetric | jca/KeyExchange.java:70:16:70:38 | jca/KeyExchange.java:70:16:70:38 | +| jca/KeyExchange.java:83:63:83:66 | KeyAgreementAlgorithm | Name | DH | jca/KeyExchange.java:83:63:83:66 | jca/KeyExchange.java:83:63:83:66 | +| jca/KeyExchange.java:83:63:83:66 | KeyAgreementAlgorithm | RawName | DH | jca/KeyExchange.java:83:63:83:66 | jca/KeyExchange.java:83:63:83:66 | +| jca/KeyExchange.java:84:26:84:29 | Constant | Description | 4096 | jca/KeyExchange.java:84:26:84:29 | jca/KeyExchange.java:84:26:84:29 | +| jca/KeyExchange.java:85:16:85:38 | Key | KeyType | Asymmetric | jca/KeyExchange.java:85:16:85:38 | jca/KeyExchange.java:85:16:85:38 | +| jca/KeyExchange.java:99:52:99:55 | KeyAgreementAlgorithm | Name | DH | jca/KeyExchange.java:99:52:99:55 | jca/KeyExchange.java:99:52:99:55 | +| jca/KeyExchange.java:99:52:99:55 | KeyAgreementAlgorithm | RawName | DH | jca/KeyExchange.java:99:52:99:55 | jca/KeyExchange.java:99:52:99:55 | +| jca/KeyExchange.java:100:17:100:26 | Key | KeyType | Unknown | jca/KeyExchange.java:100:17:100:26 | jca/KeyExchange.java:100:17:100:26 | +| jca/KeyExchange.java:101:20:101:28 | Key | KeyType | Unknown | jca/KeyExchange.java:101:20:101:28 | jca/KeyExchange.java:101:20:101:28 | +| jca/KeyExchange.java:121:49:121:59 | EllipticCurve | KeySize | 256 | jca/KeyExchange.java:121:49:121:59 | jca/KeyExchange.java:121:49:121:59 | +| jca/KeyExchange.java:121:49:121:59 | EllipticCurve | Name | secp256r1 | jca/KeyExchange.java:121:49:121:59 | jca/KeyExchange.java:121:49:121:59 | +| jca/KeyExchange.java:121:49:121:59 | EllipticCurve | ParsedName | secp256r1 | jca/KeyExchange.java:121:49:121:59 | jca/KeyExchange.java:121:49:121:59 | +| jca/KeyExchange.java:121:49:121:59 | EllipticCurve | RawName | secp256r1 | jca/KeyExchange.java:121:49:121:59 | jca/KeyExchange.java:121:49:121:59 | +| jca/KeyExchange.java:122:16:122:38 | Key | KeyType | Asymmetric | jca/KeyExchange.java:122:16:122:38 | jca/KeyExchange.java:122:16:122:38 | +| jca/KeyExchange.java:136:52:136:57 | KeyAgreementAlgorithm | Name | ECDH | jca/KeyExchange.java:136:52:136:57 | jca/KeyExchange.java:136:52:136:57 | +| jca/KeyExchange.java:136:52:136:57 | KeyAgreementAlgorithm | RawName | ECDH | jca/KeyExchange.java:136:52:136:57 | jca/KeyExchange.java:136:52:136:57 | +| jca/KeyExchange.java:137:17:137:26 | Key | KeyType | Unknown | jca/KeyExchange.java:137:17:137:26 | jca/KeyExchange.java:137:17:137:26 | +| jca/KeyExchange.java:138:20:138:28 | Key | KeyType | Unknown | jca/KeyExchange.java:138:20:138:28 | jca/KeyExchange.java:138:20:138:28 | +| jca/KeyExchange.java:156:61:156:68 | KeyAgreementAlgorithm | Name | X25519 | jca/KeyExchange.java:156:61:156:68 | jca/KeyExchange.java:156:61:156:68 | +| jca/KeyExchange.java:156:61:156:68 | KeyAgreementAlgorithm | RawName | X25519 | jca/KeyExchange.java:156:61:156:68 | jca/KeyExchange.java:156:61:156:68 | +| jca/KeyExchange.java:158:24:158:26 | Constant | Description | 255 | jca/KeyExchange.java:158:24:158:26 | jca/KeyExchange.java:158:24:158:26 | +| jca/KeyExchange.java:159:16:159:36 | Key | KeyType | Asymmetric | jca/KeyExchange.java:159:16:159:36 | jca/KeyExchange.java:159:16:159:36 | +| jca/KeyExchange.java:173:52:173:59 | KeyAgreementAlgorithm | Name | X25519 | jca/KeyExchange.java:173:52:173:59 | jca/KeyExchange.java:173:52:173:59 | +| jca/KeyExchange.java:173:52:173:59 | KeyAgreementAlgorithm | RawName | X25519 | jca/KeyExchange.java:173:52:173:59 | jca/KeyExchange.java:173:52:173:59 | +| jca/KeyExchange.java:174:17:174:26 | Key | KeyType | Unknown | jca/KeyExchange.java:174:17:174:26 | jca/KeyExchange.java:174:17:174:26 | +| jca/KeyExchange.java:175:20:175:28 | Key | KeyType | Unknown | jca/KeyExchange.java:175:20:175:28 | jca/KeyExchange.java:175:20:175:28 | +| jca/KeyExchange.java:193:61:193:66 | KeyAgreementAlgorithm | Name | X448 | jca/KeyExchange.java:193:61:193:66 | jca/KeyExchange.java:193:61:193:66 | +| jca/KeyExchange.java:193:61:193:66 | KeyAgreementAlgorithm | RawName | X448 | jca/KeyExchange.java:193:61:193:66 | jca/KeyExchange.java:193:61:193:66 | +| jca/KeyExchange.java:195:24:195:26 | Constant | Description | 448 | jca/KeyExchange.java:195:24:195:26 | jca/KeyExchange.java:195:24:195:26 | +| jca/KeyExchange.java:196:16:196:36 | Key | KeyType | Asymmetric | jca/KeyExchange.java:196:16:196:36 | jca/KeyExchange.java:196:16:196:36 | +| jca/KeyExchange.java:210:52:210:57 | KeyAgreementAlgorithm | Name | X448 | jca/KeyExchange.java:210:52:210:57 | jca/KeyExchange.java:210:52:210:57 | +| jca/KeyExchange.java:210:52:210:57 | KeyAgreementAlgorithm | RawName | X448 | jca/KeyExchange.java:210:52:210:57 | jca/KeyExchange.java:210:52:210:57 | +| jca/KeyExchange.java:211:17:211:26 | Key | KeyType | Unknown | jca/KeyExchange.java:211:17:211:26 | jca/KeyExchange.java:211:17:211:26 | +| jca/KeyExchange.java:212:20:212:28 | Key | KeyType | Unknown | jca/KeyExchange.java:212:20:212:28 | jca/KeyExchange.java:212:20:212:28 | +| jca/MACOperation.java:59:36:59:49 | Parameter | Description | message | jca/MACOperation.java:59:36:59:49 | jca/MACOperation.java:59:36:59:49 | +| jca/MACOperation.java:59:52:59:61 | Parameter | Description | key | jca/MACOperation.java:59:52:59:61 | jca/MACOperation.java:59:52:59:61 | +| jca/MACOperation.java:60:35:60:46 | KeyOperationAlgorithm | Name | HMAC | jca/MACOperation.java:60:35:60:46 | jca/MACOperation.java:60:35:60:46 | +| jca/MACOperation.java:60:35:60:46 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/MACOperation.java:60:35:60:46 | jca/MACOperation.java:60:35:60:46 | +| jca/MACOperation.java:62:18:62:26 | Key | KeyType | Unknown | jca/MACOperation.java:62:18:62:26 | jca/MACOperation.java:62:18:62:26 | +| jca/MACOperation.java:63:16:63:46 | MACOperation | KeyOperationSubtype | Mac | jca/MACOperation.java:63:16:63:46 | jca/MACOperation.java:63:16:63:46 | +| jca/MACOperation.java:70:34:70:47 | Parameter | Description | message | jca/MACOperation.java:70:34:70:47 | jca/MACOperation.java:70:34:70:47 | +| jca/MACOperation.java:70:50:70:59 | Parameter | Description | key | jca/MACOperation.java:70:50:70:59 | jca/MACOperation.java:70:50:70:59 | +| jca/MACOperation.java:71:35:71:48 | KeyOperationAlgorithm | Name | HMAC | jca/MACOperation.java:71:35:71:48 | jca/MACOperation.java:71:35:71:48 | +| jca/MACOperation.java:71:35:71:48 | KeyOperationAlgorithm | RawName | HmacSHA3-256 | jca/MACOperation.java:71:35:71:48 | jca/MACOperation.java:71:35:71:48 | +| jca/MACOperation.java:73:18:73:26 | Key | KeyType | Unknown | jca/MACOperation.java:73:18:73:26 | jca/MACOperation.java:73:18:73:26 | +| jca/MACOperation.java:74:16:74:46 | MACOperation | KeyOperationSubtype | Mac | jca/MACOperation.java:74:16:74:46 | jca/MACOperation.java:74:16:74:46 | +| jca/MACOperation.java:81:34:81:47 | Parameter | Description | message | jca/MACOperation.java:81:34:81:47 | jca/MACOperation.java:81:34:81:47 | +| jca/MACOperation.java:81:50:81:59 | Parameter | Description | key | jca/MACOperation.java:81:50:81:59 | jca/MACOperation.java:81:50:81:59 | +| jca/MACOperation.java:82:35:82:44 | KeyOperationAlgorithm | Name | UnknownMac | jca/MACOperation.java:82:35:82:44 | jca/MACOperation.java:82:35:82:44 | +| jca/MACOperation.java:82:35:82:44 | KeyOperationAlgorithm | RawName | Poly1305 | jca/MACOperation.java:82:35:82:44 | jca/MACOperation.java:82:35:82:44 | +| jca/MACOperation.java:84:18:84:26 | Key | KeyType | Unknown | jca/MACOperation.java:84:18:84:26 | jca/MACOperation.java:84:18:84:26 | +| jca/MACOperation.java:85:16:85:46 | MACOperation | KeyOperationSubtype | Mac | jca/MACOperation.java:85:16:85:46 | jca/MACOperation.java:85:16:85:46 | +| jca/MACOperation.java:92:30:92:43 | Parameter | Description | message | jca/MACOperation.java:92:30:92:43 | jca/MACOperation.java:92:30:92:43 | +| jca/MACOperation.java:92:46:92:55 | Parameter | Description | key | jca/MACOperation.java:92:46:92:55 | jca/MACOperation.java:92:46:92:55 | +| jca/MACOperation.java:94:35:94:40 | KeyOperationAlgorithm | Name | UnknownMac | jca/MACOperation.java:94:35:94:40 | jca/MACOperation.java:94:35:94:40 | +| jca/MACOperation.java:94:35:94:40 | KeyOperationAlgorithm | RawName | GMac | jca/MACOperation.java:94:35:94:40 | jca/MACOperation.java:94:35:94:40 | +| jca/MACOperation.java:98:18:98:26 | Key | KeyType | Unknown | jca/MACOperation.java:98:18:98:26 | jca/MACOperation.java:98:18:98:26 | +| jca/MACOperation.java:99:16:99:46 | MACOperation | KeyOperationSubtype | Mac | jca/MACOperation.java:99:16:99:46 | jca/MACOperation.java:99:16:99:46 | +| jca/MACOperation.java:106:30:106:43 | Parameter | Description | message | jca/MACOperation.java:106:30:106:43 | jca/MACOperation.java:106:30:106:43 | +| jca/MACOperation.java:106:46:106:55 | Parameter | Description | key | jca/MACOperation.java:106:46:106:55 | jca/MACOperation.java:106:46:106:55 | +| jca/MACOperation.java:107:35:107:43 | Constant | Description | "KMAC128" | jca/MACOperation.java:107:35:107:43 | jca/MACOperation.java:107:35:107:43 | +| jca/MACOperation.java:109:18:109:26 | Key | KeyType | Unknown | jca/MACOperation.java:109:18:109:26 | jca/MACOperation.java:109:18:109:26 | +| jca/MACOperation.java:110:16:110:46 | MACOperation | KeyOperationSubtype | Mac | jca/MACOperation.java:110:16:110:46 | jca/MACOperation.java:110:16:110:46 | +| jca/MACOperation.java:117:36:117:49 | Parameter | Description | message | jca/MACOperation.java:117:36:117:49 | jca/MACOperation.java:117:36:117:49 | +| jca/MACOperation.java:117:52:117:61 | Parameter | Description | key | jca/MACOperation.java:117:52:117:61 | jca/MACOperation.java:117:52:117:61 | +| jca/MACOperation.java:118:35:118:44 | KeyOperationAlgorithm | Name | HMAC | jca/MACOperation.java:118:35:118:44 | jca/MACOperation.java:118:35:118:44 | +| jca/MACOperation.java:118:35:118:44 | KeyOperationAlgorithm | RawName | HmacSHA1 | jca/MACOperation.java:118:35:118:44 | jca/MACOperation.java:118:35:118:44 | +| jca/MACOperation.java:120:18:120:26 | Key | KeyType | Unknown | jca/MACOperation.java:120:18:120:26 | jca/MACOperation.java:120:18:120:26 | +| jca/MACOperation.java:121:16:121:46 | MACOperation | KeyOperationSubtype | Mac | jca/MACOperation.java:121:16:121:46 | jca/MACOperation.java:121:16:121:46 | +| jca/MACOperation.java:133:34:133:49 | Parameter | Description | macOutput | jca/MACOperation.java:133:34:133:49 | jca/MACOperation.java:133:34:133:49 | +| jca/MACOperation.java:136:44:136:62 | KeyOperationAlgorithm | Name | AES | jca/MACOperation.java:136:44:136:62 | jca/MACOperation.java:136:44:136:62 | +| jca/MACOperation.java:136:44:136:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/MACOperation.java:136:44:136:62 | jca/MACOperation.java:136:44:136:62 | +| jca/MACOperation.java:136:44:136:62 | KeyOperationAlgorithm | Structure | Block | jca/MACOperation.java:136:44:136:62 | jca/MACOperation.java:136:44:136:62 | +| jca/MACOperation.java:136:44:136:62 | ModeOfOperation | Name | GCM | jca/MACOperation.java:136:44:136:62 | jca/MACOperation.java:136:44:136:62 | +| jca/MACOperation.java:136:44:136:62 | ModeOfOperation | RawName | GCM | jca/MACOperation.java:136:44:136:62 | jca/MACOperation.java:136:44:136:62 | +| jca/MACOperation.java:136:44:136:62 | PaddingAlgorithm | Name | UnknownPadding | jca/MACOperation.java:136:44:136:62 | jca/MACOperation.java:136:44:136:62 | +| jca/MACOperation.java:136:44:136:62 | PaddingAlgorithm | RawName | NoPadding | jca/MACOperation.java:136:44:136:62 | jca/MACOperation.java:136:44:136:62 | +| jca/MACOperation.java:137:42:137:44 | Key | KeyType | Unknown | jca/MACOperation.java:137:42:137:44 | jca/MACOperation.java:137:42:137:44 | +| jca/MACOperation.java:138:32:138:74 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/MACOperation.java:138:32:138:74 | jca/MACOperation.java:138:32:138:74 | +| jca/MACOperation.java:138:47:138:62 | Constant | Description | "Sensitive Data" | jca/MACOperation.java:138:47:138:62 | jca/MACOperation.java:138:47:138:62 | +| jca/MACOperation.java:150:36:150:51 | Parameter | Description | macOutput | jca/MACOperation.java:150:36:150:51 | jca/MACOperation.java:150:36:150:51 | +| jca/MACOperation.java:166:47:166:62 | Parameter | Description | macOutput | jca/MACOperation.java:166:47:166:62 | jca/MACOperation.java:166:47:166:62 | +| jca/MACOperation.java:170:77:170:81 | Constant | Description | 10000 | jca/MACOperation.java:170:77:170:81 | jca/MACOperation.java:170:77:170:81 | +| jca/MACOperation.java:170:84:170:86 | Constant | Description | 256 | jca/MACOperation.java:170:84:170:86 | jca/MACOperation.java:170:84:170:86 | +| jca/MACOperation.java:171:65:171:86 | HMACAlgorithm | Name | HMAC | jca/MACOperation.java:171:65:171:86 | jca/MACOperation.java:171:65:171:86 | +| jca/MACOperation.java:171:65:171:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/MACOperation.java:171:65:171:86 | jca/MACOperation.java:171:65:171:86 | +| jca/MACOperation.java:171:65:171:86 | HashAlgorithm | DigestSize | 256 | jca/MACOperation.java:171:65:171:86 | jca/MACOperation.java:171:65:171:86 | +| jca/MACOperation.java:171:65:171:86 | HashAlgorithm | Name | SHA2 | jca/MACOperation.java:171:65:171:86 | jca/MACOperation.java:171:65:171:86 | +| jca/MACOperation.java:171:65:171:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/MACOperation.java:171:65:171:86 | jca/MACOperation.java:171:65:171:86 | +| jca/MACOperation.java:171:65:171:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/MACOperation.java:171:65:171:86 | jca/MACOperation.java:171:65:171:86 | +| jca/MACOperation.java:171:65:171:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/MACOperation.java:171:65:171:86 | jca/MACOperation.java:171:65:171:86 | +| jca/MACOperation.java:172:30:172:57 | Key | KeyType | Symmetric | jca/MACOperation.java:172:30:172:57 | jca/MACOperation.java:172:30:172:57 | +| jca/MACOperation.java:172:30:172:57 | KeyDerivation | Iterations | Constant:10000 | jca/MACOperation.java:170:77:170:81 | jca/MACOperation.java:170:77:170:81 | +| jca/MACOperation.java:172:30:172:57 | KeyDerivation | KeySize | Constant:256 | jca/MACOperation.java:170:84:170:86 | jca/MACOperation.java:170:84:170:86 | +| jca/MACOperation.java:180:44:180:62 | KeyOperationAlgorithm | Name | AES | jca/MACOperation.java:180:44:180:62 | jca/MACOperation.java:180:44:180:62 | +| jca/MACOperation.java:180:44:180:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/MACOperation.java:180:44:180:62 | jca/MACOperation.java:180:44:180:62 | +| jca/MACOperation.java:180:44:180:62 | KeyOperationAlgorithm | Structure | Block | jca/MACOperation.java:180:44:180:62 | jca/MACOperation.java:180:44:180:62 | +| jca/MACOperation.java:180:44:180:62 | ModeOfOperation | Name | GCM | jca/MACOperation.java:180:44:180:62 | jca/MACOperation.java:180:44:180:62 | +| jca/MACOperation.java:180:44:180:62 | ModeOfOperation | RawName | GCM | jca/MACOperation.java:180:44:180:62 | jca/MACOperation.java:180:44:180:62 | +| jca/MACOperation.java:180:44:180:62 | PaddingAlgorithm | Name | UnknownPadding | jca/MACOperation.java:180:44:180:62 | jca/MACOperation.java:180:44:180:62 | +| jca/MACOperation.java:180:44:180:62 | PaddingAlgorithm | RawName | NoPadding | jca/MACOperation.java:180:44:180:62 | jca/MACOperation.java:180:44:180:62 | +| jca/MACOperation.java:181:42:181:54 | Key | KeyType | Unknown | jca/MACOperation.java:181:42:181:54 | jca/MACOperation.java:181:42:181:54 | +| jca/MACOperation.java:182:29:182:78 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/MACOperation.java:182:29:182:78 | jca/MACOperation.java:182:29:182:78 | +| jca/MACOperation.java:182:44:182:66 | Constant | Description | "Further Use Test Data" | jca/MACOperation.java:182:44:182:66 | jca/MACOperation.java:182:44:182:66 | +| jca/MACOperation.java:185:35:185:46 | KeyOperationAlgorithm | Name | HMAC | jca/MACOperation.java:185:35:185:46 | jca/MACOperation.java:185:35:185:46 | +| jca/MACOperation.java:185:35:185:46 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/MACOperation.java:185:35:185:46 | jca/MACOperation.java:185:35:185:46 | +| jca/MACOperation.java:186:18:186:30 | Key | KeyType | Unknown | jca/MACOperation.java:186:18:186:30 | jca/MACOperation.java:186:18:186:30 | +| jca/MACOperation.java:187:30:187:52 | MACOperation | KeyOperationSubtype | Mac | jca/MACOperation.java:187:30:187:52 | jca/MACOperation.java:187:30:187:52 | +| jca/MACOperation.java:216:44:216:62 | KeyOperationAlgorithm | Name | AES | jca/MACOperation.java:216:44:216:62 | jca/MACOperation.java:216:44:216:62 | +| jca/MACOperation.java:216:44:216:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/MACOperation.java:216:44:216:62 | jca/MACOperation.java:216:44:216:62 | +| jca/MACOperation.java:216:44:216:62 | KeyOperationAlgorithm | Structure | Block | jca/MACOperation.java:216:44:216:62 | jca/MACOperation.java:216:44:216:62 | +| jca/MACOperation.java:216:44:216:62 | ModeOfOperation | Name | GCM | jca/MACOperation.java:216:44:216:62 | jca/MACOperation.java:216:44:216:62 | +| jca/MACOperation.java:216:44:216:62 | ModeOfOperation | RawName | GCM | jca/MACOperation.java:216:44:216:62 | jca/MACOperation.java:216:44:216:62 | +| jca/MACOperation.java:216:44:216:62 | PaddingAlgorithm | Name | UnknownPadding | jca/MACOperation.java:216:44:216:62 | jca/MACOperation.java:216:44:216:62 | +| jca/MACOperation.java:216:44:216:62 | PaddingAlgorithm | RawName | NoPadding | jca/MACOperation.java:216:44:216:62 | jca/MACOperation.java:216:44:216:62 | +| jca/MACOperation.java:218:42:218:44 | Key | KeyType | Unknown | jca/MACOperation.java:218:42:218:44 | jca/MACOperation.java:218:42:218:44 | +| jca/MACOperation.java:219:32:219:51 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/MACOperation.java:219:32:219:51 | jca/MACOperation.java:219:32:219:51 | +| jca/MACOperation.java:232:56:232:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/MACOperation.java:233:21:233:23 | jca/MACOperation.java:233:21:233:23 | +| jca/MACOperation.java:232:56:232:60 | KeyOperationAlgorithm | Name | AES | jca/MACOperation.java:232:56:232:60 | jca/MACOperation.java:232:56:232:60 | +| jca/MACOperation.java:232:56:232:60 | KeyOperationAlgorithm | RawName | AES | jca/MACOperation.java:232:56:232:60 | jca/MACOperation.java:232:56:232:60 | +| jca/MACOperation.java:232:56:232:60 | KeyOperationAlgorithm | Structure | Block | jca/MACOperation.java:232:56:232:60 | jca/MACOperation.java:232:56:232:60 | +| jca/MACOperation.java:233:21:233:23 | Constant | Description | 256 | jca/MACOperation.java:233:21:233:23 | jca/MACOperation.java:233:21:233:23 | +| jca/MACOperation.java:234:16:234:35 | Key | KeyType | Symmetric | jca/MACOperation.java:234:16:234:35 | jca/MACOperation.java:234:16:234:35 | +| jca/MACOperation.java:246:9:246:42 | RandomNumberGeneration | Description | nextBytes | jca/MACOperation.java:246:9:246:42 | jca/MACOperation.java:246:9:246:42 | +| jca/MACOperation.java:246:38:246:41 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/MACOperation.java:246:38:246:41 | jca/MACOperation.java:246:38:246:41 | +| jca/Nonce.java:24:35:24:46 | KeyOperationAlgorithm | Name | HMAC | jca/Nonce.java:24:35:24:46 | jca/Nonce.java:24:35:24:46 | +| jca/Nonce.java:24:35:24:46 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/Nonce.java:24:35:24:46 | jca/Nonce.java:24:35:24:46 | +| jca/Nonce.java:25:18:25:20 | Key | KeyType | Unknown | jca/Nonce.java:25:18:25:20 | jca/Nonce.java:25:18:25:20 | +| jca/Nonce.java:27:28:27:69 | MACOperation | KeyOperationSubtype | Mac | jca/Nonce.java:27:28:27:69 | jca/Nonce.java:27:28:27:69 | +| jca/Nonce.java:27:40:27:57 | Constant | Description | "Simple Test Data" | jca/Nonce.java:27:40:27:57 | jca/Nonce.java:27:40:27:57 | +| jca/Nonce.java:37:35:37:46 | KeyOperationAlgorithm | Name | HMAC | jca/Nonce.java:37:35:37:46 | jca/Nonce.java:37:35:37:46 | +| jca/Nonce.java:37:35:37:46 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/Nonce.java:37:35:37:46 | jca/Nonce.java:37:35:37:46 | +| jca/Nonce.java:38:18:38:20 | Key | KeyType | Unknown | jca/Nonce.java:38:18:38:20 | jca/Nonce.java:38:18:38:20 | +| jca/Nonce.java:40:28:40:67 | MACOperation | KeyOperationSubtype | Mac | jca/Nonce.java:40:28:40:67 | jca/Nonce.java:40:28:40:67 | +| jca/Nonce.java:40:40:40:55 | Constant | Description | "Sensitive Data" | jca/Nonce.java:40:40:40:55 | jca/Nonce.java:40:40:40:55 | +| jca/Nonce.java:47:39:47:51 | Parameter | Description | key | jca/Nonce.java:47:39:47:51 | jca/Nonce.java:47:39:47:51 | +| jca/Nonce.java:47:54:47:69 | Parameter | Description | plaintext | jca/Nonce.java:47:54:47:69 | jca/Nonce.java:47:54:47:69 | +| jca/Nonce.java:50:44:50:62 | KeyOperationAlgorithm | Name | AES | jca/Nonce.java:50:44:50:62 | jca/Nonce.java:50:44:50:62 | +| jca/Nonce.java:50:44:50:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/Nonce.java:50:44:50:62 | jca/Nonce.java:50:44:50:62 | +| jca/Nonce.java:50:44:50:62 | KeyOperationAlgorithm | Structure | Block | jca/Nonce.java:50:44:50:62 | jca/Nonce.java:50:44:50:62 | +| jca/Nonce.java:50:44:50:62 | ModeOfOperation | Name | GCM | jca/Nonce.java:50:44:50:62 | jca/Nonce.java:50:44:50:62 | +| jca/Nonce.java:50:44:50:62 | ModeOfOperation | RawName | GCM | jca/Nonce.java:50:44:50:62 | jca/Nonce.java:50:44:50:62 | +| jca/Nonce.java:50:44:50:62 | PaddingAlgorithm | Name | UnknownPadding | jca/Nonce.java:50:44:50:62 | jca/Nonce.java:50:44:50:62 | +| jca/Nonce.java:50:44:50:62 | PaddingAlgorithm | RawName | NoPadding | jca/Nonce.java:50:44:50:62 | jca/Nonce.java:50:44:50:62 | +| jca/Nonce.java:51:42:51:44 | Key | KeyType | Unknown | jca/Nonce.java:51:42:51:44 | jca/Nonce.java:51:42:51:44 | +| jca/Nonce.java:52:29:52:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Nonce.java:52:29:52:53 | jca/Nonce.java:52:29:52:53 | +| jca/Nonce.java:58:37:58:49 | Parameter | Description | key | jca/Nonce.java:58:37:58:49 | jca/Nonce.java:58:37:58:49 | +| jca/Nonce.java:58:52:58:67 | Parameter | Description | plaintext | jca/Nonce.java:58:52:58:67 | jca/Nonce.java:58:52:58:67 | +| jca/Nonce.java:61:44:61:62 | KeyOperationAlgorithm | Name | AES | jca/Nonce.java:61:44:61:62 | jca/Nonce.java:61:44:61:62 | +| jca/Nonce.java:61:44:61:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/Nonce.java:61:44:61:62 | jca/Nonce.java:61:44:61:62 | +| jca/Nonce.java:61:44:61:62 | KeyOperationAlgorithm | Structure | Block | jca/Nonce.java:61:44:61:62 | jca/Nonce.java:61:44:61:62 | +| jca/Nonce.java:61:44:61:62 | ModeOfOperation | Name | GCM | jca/Nonce.java:61:44:61:62 | jca/Nonce.java:61:44:61:62 | +| jca/Nonce.java:61:44:61:62 | ModeOfOperation | RawName | GCM | jca/Nonce.java:61:44:61:62 | jca/Nonce.java:61:44:61:62 | +| jca/Nonce.java:61:44:61:62 | PaddingAlgorithm | Name | UnknownPadding | jca/Nonce.java:61:44:61:62 | jca/Nonce.java:61:44:61:62 | +| jca/Nonce.java:61:44:61:62 | PaddingAlgorithm | RawName | NoPadding | jca/Nonce.java:61:44:61:62 | jca/Nonce.java:61:44:61:62 | +| jca/Nonce.java:62:42:62:44 | Key | KeyType | Unknown | jca/Nonce.java:62:42:62:44 | jca/Nonce.java:62:42:62:44 | +| jca/Nonce.java:63:29:63:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/Nonce.java:63:29:63:53 | jca/Nonce.java:63:29:63:53 | +| jca/Nonce.java:70:53:70:64 | KeyOperationAlgorithm | Name | HMAC | jca/Nonce.java:70:53:70:64 | jca/Nonce.java:70:53:70:64 | +| jca/Nonce.java:70:53:70:64 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/Nonce.java:70:53:70:64 | jca/Nonce.java:70:53:70:64 | +| jca/Nonce.java:78:18:78:20 | Key | KeyType | Unknown | jca/Nonce.java:78:18:78:20 | jca/Nonce.java:78:18:78:20 | +| jca/Nonce.java:80:28:80:67 | MACOperation | KeyOperationSubtype | Mac | jca/Nonce.java:80:28:80:67 | jca/Nonce.java:80:28:80:67 | +| jca/Nonce.java:80:40:80:55 | Constant | Description | "Sensitive Data" | jca/Nonce.java:80:40:80:55 | jca/Nonce.java:80:40:80:55 | +| jca/Nonce.java:92:56:92:67 | Constant | Description | "HmacSHA256" | jca/Nonce.java:92:56:92:67 | jca/Nonce.java:92:56:92:67 | +| jca/Nonce.java:93:16:93:35 | Key | KeyType | Symmetric | jca/Nonce.java:93:16:93:35 | jca/Nonce.java:93:16:93:35 | +| jca/Nonce.java:98:9:98:43 | RandomNumberGeneration | Description | nextBytes | jca/Nonce.java:98:9:98:43 | jca/Nonce.java:98:9:98:43 | +| jca/Nonce.java:98:38:98:42 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/Nonce.java:98:38:98:42 | jca/Nonce.java:98:38:98:42 | +| jca/Nonce.java:112:16:112:33 | Constant | Description | "BADNONCEBADNONCE" | jca/Nonce.java:112:16:112:33 | jca/Nonce.java:112:16:112:33 | +| jca/PrngTest.java:152:56:152:60 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/PrngTest.java:153:21:153:23 | jca/PrngTest.java:153:21:153:23 | +| jca/PrngTest.java:152:56:152:60 | KeyOperationAlgorithm | Name | AES | jca/PrngTest.java:152:56:152:60 | jca/PrngTest.java:152:56:152:60 | +| jca/PrngTest.java:152:56:152:60 | KeyOperationAlgorithm | RawName | AES | jca/PrngTest.java:152:56:152:60 | jca/PrngTest.java:152:56:152:60 | +| jca/PrngTest.java:152:56:152:60 | KeyOperationAlgorithm | Structure | Block | jca/PrngTest.java:152:56:152:60 | jca/PrngTest.java:152:56:152:60 | +| jca/PrngTest.java:153:21:153:23 | Constant | Description | 256 | jca/PrngTest.java:153:21:153:23 | jca/PrngTest.java:153:21:153:23 | +| jca/PrngTest.java:154:16:154:35 | Key | KeyType | Symmetric | jca/PrngTest.java:154:16:154:35 | jca/PrngTest.java:154:16:154:35 | +| jca/SignEncryptCombinations.java:52:49:52:59 | EllipticCurve | KeySize | 256 | jca/SignEncryptCombinations.java:52:49:52:59 | jca/SignEncryptCombinations.java:52:49:52:59 | +| jca/SignEncryptCombinations.java:52:49:52:59 | EllipticCurve | Name | secp256r1 | jca/SignEncryptCombinations.java:52:49:52:59 | jca/SignEncryptCombinations.java:52:49:52:59 | +| jca/SignEncryptCombinations.java:52:49:52:59 | EllipticCurve | ParsedName | secp256r1 | jca/SignEncryptCombinations.java:52:49:52:59 | jca/SignEncryptCombinations.java:52:49:52:59 | +| jca/SignEncryptCombinations.java:52:49:52:59 | EllipticCurve | RawName | secp256r1 | jca/SignEncryptCombinations.java:52:49:52:59 | jca/SignEncryptCombinations.java:52:49:52:59 | +| jca/SignEncryptCombinations.java:53:16:53:38 | Key | KeyType | Asymmetric | jca/SignEncryptCombinations.java:53:16:53:38 | jca/SignEncryptCombinations.java:53:16:53:38 | +| jca/SignEncryptCombinations.java:61:53:61:69 | HashAlgorithm | DigestSize | 256 | jca/SignEncryptCombinations.java:61:53:61:69 | jca/SignEncryptCombinations.java:61:53:61:69 | +| jca/SignEncryptCombinations.java:61:53:61:69 | HashAlgorithm | Name | SHA2 | jca/SignEncryptCombinations.java:61:53:61:69 | jca/SignEncryptCombinations.java:61:53:61:69 | +| jca/SignEncryptCombinations.java:61:53:61:69 | HashAlgorithm | RawName | SHA256withECDSA | jca/SignEncryptCombinations.java:61:53:61:69 | jca/SignEncryptCombinations.java:61:53:61:69 | +| jca/SignEncryptCombinations.java:61:53:61:69 | KeyOperationAlgorithm | Name | ECDSA | jca/SignEncryptCombinations.java:61:53:61:69 | jca/SignEncryptCombinations.java:61:53:61:69 | +| jca/SignEncryptCombinations.java:61:53:61:69 | KeyOperationAlgorithm | RawName | SHA256withECDSA | jca/SignEncryptCombinations.java:61:53:61:69 | jca/SignEncryptCombinations.java:61:53:61:69 | +| jca/SignEncryptCombinations.java:62:28:62:34 | Key | KeyType | Unknown | jca/SignEncryptCombinations.java:62:28:62:34 | jca/SignEncryptCombinations.java:62:28:62:34 | +| jca/SignEncryptCombinations.java:64:16:64:31 | SignOperation | KeyOperationSubtype | Sign | jca/SignEncryptCombinations.java:64:16:64:31 | jca/SignEncryptCombinations.java:64:16:64:31 | +| jca/SignEncryptCombinations.java:68:53:68:69 | HashAlgorithm | DigestSize | 256 | jca/SignEncryptCombinations.java:68:53:68:69 | jca/SignEncryptCombinations.java:68:53:68:69 | +| jca/SignEncryptCombinations.java:68:53:68:69 | HashAlgorithm | Name | SHA2 | jca/SignEncryptCombinations.java:68:53:68:69 | jca/SignEncryptCombinations.java:68:53:68:69 | +| jca/SignEncryptCombinations.java:68:53:68:69 | HashAlgorithm | RawName | SHA256withECDSA | jca/SignEncryptCombinations.java:68:53:68:69 | jca/SignEncryptCombinations.java:68:53:68:69 | +| jca/SignEncryptCombinations.java:68:53:68:69 | KeyOperationAlgorithm | Name | ECDSA | jca/SignEncryptCombinations.java:68:53:68:69 | jca/SignEncryptCombinations.java:68:53:68:69 | +| jca/SignEncryptCombinations.java:68:53:68:69 | KeyOperationAlgorithm | RawName | SHA256withECDSA | jca/SignEncryptCombinations.java:68:53:68:69 | jca/SignEncryptCombinations.java:68:53:68:69 | +| jca/SignEncryptCombinations.java:69:30:69:35 | Key | KeyType | Unknown | jca/SignEncryptCombinations.java:69:30:69:35 | jca/SignEncryptCombinations.java:69:30:69:35 | +| jca/SignEncryptCombinations.java:71:16:71:47 | VerifyOperation | KeyOperationSubtype | Verify | jca/SignEncryptCombinations.java:71:16:71:47 | jca/SignEncryptCombinations.java:71:16:71:47 | +| jca/SignEncryptCombinations.java:82:52:82:56 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/SignEncryptCombinations.java:83:17:83:19 | jca/SignEncryptCombinations.java:83:17:83:19 | +| jca/SignEncryptCombinations.java:82:52:82:56 | KeyOperationAlgorithm | Name | AES | jca/SignEncryptCombinations.java:82:52:82:56 | jca/SignEncryptCombinations.java:82:52:82:56 | +| jca/SignEncryptCombinations.java:82:52:82:56 | KeyOperationAlgorithm | RawName | AES | jca/SignEncryptCombinations.java:82:52:82:56 | jca/SignEncryptCombinations.java:82:52:82:56 | +| jca/SignEncryptCombinations.java:82:52:82:56 | KeyOperationAlgorithm | Structure | Block | jca/SignEncryptCombinations.java:82:52:82:56 | jca/SignEncryptCombinations.java:82:52:82:56 | +| jca/SignEncryptCombinations.java:83:17:83:19 | Constant | Description | 256 | jca/SignEncryptCombinations.java:83:17:83:19 | jca/SignEncryptCombinations.java:83:17:83:19 | +| jca/SignEncryptCombinations.java:84:16:84:31 | Key | KeyType | Symmetric | jca/SignEncryptCombinations.java:84:16:84:31 | jca/SignEncryptCombinations.java:84:16:84:31 | +| jca/SignEncryptCombinations.java:92:44:92:62 | KeyOperationAlgorithm | Name | AES | jca/SignEncryptCombinations.java:92:44:92:62 | jca/SignEncryptCombinations.java:92:44:92:62 | +| jca/SignEncryptCombinations.java:92:44:92:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/SignEncryptCombinations.java:92:44:92:62 | jca/SignEncryptCombinations.java:92:44:92:62 | +| jca/SignEncryptCombinations.java:92:44:92:62 | KeyOperationAlgorithm | Structure | Block | jca/SignEncryptCombinations.java:92:44:92:62 | jca/SignEncryptCombinations.java:92:44:92:62 | +| jca/SignEncryptCombinations.java:92:44:92:62 | ModeOfOperation | Name | GCM | jca/SignEncryptCombinations.java:92:44:92:62 | jca/SignEncryptCombinations.java:92:44:92:62 | +| jca/SignEncryptCombinations.java:92:44:92:62 | ModeOfOperation | RawName | GCM | jca/SignEncryptCombinations.java:92:44:92:62 | jca/SignEncryptCombinations.java:92:44:92:62 | +| jca/SignEncryptCombinations.java:92:44:92:62 | PaddingAlgorithm | Name | UnknownPadding | jca/SignEncryptCombinations.java:92:44:92:62 | jca/SignEncryptCombinations.java:92:44:92:62 | +| jca/SignEncryptCombinations.java:92:44:92:62 | PaddingAlgorithm | RawName | NoPadding | jca/SignEncryptCombinations.java:92:44:92:62 | jca/SignEncryptCombinations.java:92:44:92:62 | +| jca/SignEncryptCombinations.java:94:9:94:28 | RandomNumberGeneration | Description | nextBytes | jca/SignEncryptCombinations.java:94:9:94:28 | jca/SignEncryptCombinations.java:94:9:94:28 | +| jca/SignEncryptCombinations.java:94:26:94:27 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SignEncryptCombinations.java:94:26:94:27 | jca/SignEncryptCombinations.java:94:26:94:27 | +| jca/SignEncryptCombinations.java:96:42:96:44 | Key | KeyType | Unknown | jca/SignEncryptCombinations.java:96:42:96:44 | jca/SignEncryptCombinations.java:96:42:96:44 | +| jca/SignEncryptCombinations.java:97:29:97:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SignEncryptCombinations.java:97:29:97:53 | jca/SignEncryptCombinations.java:97:29:97:53 | +| jca/SignEncryptCombinations.java:111:44:111:62 | KeyOperationAlgorithm | Name | AES | jca/SignEncryptCombinations.java:111:44:111:62 | jca/SignEncryptCombinations.java:111:44:111:62 | +| jca/SignEncryptCombinations.java:111:44:111:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/SignEncryptCombinations.java:111:44:111:62 | jca/SignEncryptCombinations.java:111:44:111:62 | +| jca/SignEncryptCombinations.java:111:44:111:62 | KeyOperationAlgorithm | Structure | Block | jca/SignEncryptCombinations.java:111:44:111:62 | jca/SignEncryptCombinations.java:111:44:111:62 | +| jca/SignEncryptCombinations.java:111:44:111:62 | ModeOfOperation | Name | GCM | jca/SignEncryptCombinations.java:111:44:111:62 | jca/SignEncryptCombinations.java:111:44:111:62 | +| jca/SignEncryptCombinations.java:111:44:111:62 | ModeOfOperation | RawName | GCM | jca/SignEncryptCombinations.java:111:44:111:62 | jca/SignEncryptCombinations.java:111:44:111:62 | +| jca/SignEncryptCombinations.java:111:44:111:62 | PaddingAlgorithm | Name | UnknownPadding | jca/SignEncryptCombinations.java:111:44:111:62 | jca/SignEncryptCombinations.java:111:44:111:62 | +| jca/SignEncryptCombinations.java:111:44:111:62 | PaddingAlgorithm | RawName | NoPadding | jca/SignEncryptCombinations.java:111:44:111:62 | jca/SignEncryptCombinations.java:111:44:111:62 | +| jca/SignEncryptCombinations.java:112:42:112:44 | Key | KeyType | Unknown | jca/SignEncryptCombinations.java:112:42:112:44 | jca/SignEncryptCombinations.java:112:42:112:44 | +| jca/SignEncryptCombinations.java:113:16:113:41 | DecryptOperation | KeyOperationSubtype | Decrypt | jca/SignEncryptCombinations.java:113:16:113:41 | jca/SignEncryptCombinations.java:113:16:113:41 | +| jca/SignEncryptCombinations.java:121:35:121:46 | KeyOperationAlgorithm | Name | HMAC | jca/SignEncryptCombinations.java:121:35:121:46 | jca/SignEncryptCombinations.java:121:35:121:46 | +| jca/SignEncryptCombinations.java:121:35:121:46 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/SignEncryptCombinations.java:121:35:121:46 | jca/SignEncryptCombinations.java:121:35:121:46 | +| jca/SignEncryptCombinations.java:122:18:122:20 | Key | KeyType | Unknown | jca/SignEncryptCombinations.java:122:18:122:20 | jca/SignEncryptCombinations.java:122:18:122:20 | +| jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | KeyOperationSubtype | Mac | jca/SignEncryptCombinations.java:123:16:123:32 | jca/SignEncryptCombinations.java:123:16:123:32 | +| jca/SignEncryptCombinations.java:335:26:335:47 | Constant | Description | "Hello, combinations!" | jca/SignEncryptCombinations.java:335:26:335:47 | jca/SignEncryptCombinations.java:335:26:335:47 | +| jca/SignatureOperation.java:52:61:52:65 | KeyOperationAlgorithm | KeySize | Constant:2048 | jca/SignatureOperation.java:53:24:53:27 | jca/SignatureOperation.java:53:24:53:27 | +| jca/SignatureOperation.java:52:61:52:65 | KeyOperationAlgorithm | Name | RSA | jca/SignatureOperation.java:52:61:52:65 | jca/SignatureOperation.java:52:61:52:65 | +| jca/SignatureOperation.java:52:61:52:65 | KeyOperationAlgorithm | RawName | RSA | jca/SignatureOperation.java:52:61:52:65 | jca/SignatureOperation.java:52:61:52:65 | +| jca/SignatureOperation.java:53:24:53:27 | Constant | Description | 2048 | jca/SignatureOperation.java:53:24:53:27 | jca/SignatureOperation.java:53:24:53:27 | +| jca/SignatureOperation.java:54:16:54:36 | Key | KeyType | Asymmetric | jca/SignatureOperation.java:54:16:54:36 | jca/SignatureOperation.java:54:16:54:36 | +| jca/SignatureOperation.java:63:53:63:74 | HashAlgorithm | DigestSize | 256 | jca/SignatureOperation.java:63:53:63:74 | jca/SignatureOperation.java:63:53:63:74 | +| jca/SignatureOperation.java:63:53:63:74 | HashAlgorithm | Name | SHA2 | jca/SignatureOperation.java:63:53:63:74 | jca/SignatureOperation.java:63:53:63:74 | +| jca/SignatureOperation.java:63:53:63:74 | HashAlgorithm | RawName | SHA256withRSAandMGF1 | jca/SignatureOperation.java:63:53:63:74 | jca/SignatureOperation.java:63:53:63:74 | +| jca/SignatureOperation.java:63:53:63:74 | KeyOperationAlgorithm | Name | RSA | jca/SignatureOperation.java:63:53:63:74 | jca/SignatureOperation.java:63:53:63:74 | +| jca/SignatureOperation.java:63:53:63:74 | KeyOperationAlgorithm | RawName | SHA256withRSAandMGF1 | jca/SignatureOperation.java:63:53:63:74 | jca/SignatureOperation.java:63:53:63:74 | +| jca/SignatureOperation.java:64:28:64:37 | Key | KeyType | Unknown | jca/SignatureOperation.java:64:28:64:37 | jca/SignatureOperation.java:64:28:64:37 | +| jca/SignatureOperation.java:66:16:66:31 | SignOperation | KeyOperationSubtype | Sign | jca/SignatureOperation.java:66:16:66:31 | jca/SignatureOperation.java:66:16:66:31 | +| jca/SignatureOperation.java:75:53:75:74 | HashAlgorithm | DigestSize | 256 | jca/SignatureOperation.java:75:53:75:74 | jca/SignatureOperation.java:75:53:75:74 | +| jca/SignatureOperation.java:75:53:75:74 | HashAlgorithm | Name | SHA2 | jca/SignatureOperation.java:75:53:75:74 | jca/SignatureOperation.java:75:53:75:74 | +| jca/SignatureOperation.java:75:53:75:74 | HashAlgorithm | RawName | SHA256withRSAandMGF1 | jca/SignatureOperation.java:75:53:75:74 | jca/SignatureOperation.java:75:53:75:74 | +| jca/SignatureOperation.java:75:53:75:74 | KeyOperationAlgorithm | Name | RSA | jca/SignatureOperation.java:75:53:75:74 | jca/SignatureOperation.java:75:53:75:74 | +| jca/SignatureOperation.java:75:53:75:74 | KeyOperationAlgorithm | RawName | SHA256withRSAandMGF1 | jca/SignatureOperation.java:75:53:75:74 | jca/SignatureOperation.java:75:53:75:74 | +| jca/SignatureOperation.java:76:30:76:38 | Key | KeyType | Unknown | jca/SignatureOperation.java:76:30:76:38 | jca/SignatureOperation.java:76:30:76:38 | +| jca/SignatureOperation.java:78:16:78:41 | VerifyOperation | KeyOperationSubtype | Verify | jca/SignatureOperation.java:78:16:78:41 | jca/SignatureOperation.java:78:16:78:41 | +| jca/SignatureOperation.java:93:49:93:59 | EllipticCurve | KeySize | 256 | jca/SignatureOperation.java:93:49:93:59 | jca/SignatureOperation.java:93:49:93:59 | +| jca/SignatureOperation.java:93:49:93:59 | EllipticCurve | Name | secp256r1 | jca/SignatureOperation.java:93:49:93:59 | jca/SignatureOperation.java:93:49:93:59 | +| jca/SignatureOperation.java:93:49:93:59 | EllipticCurve | ParsedName | secp256r1 | jca/SignatureOperation.java:93:49:93:59 | jca/SignatureOperation.java:93:49:93:59 | +| jca/SignatureOperation.java:93:49:93:59 | EllipticCurve | RawName | secp256r1 | jca/SignatureOperation.java:93:49:93:59 | jca/SignatureOperation.java:93:49:93:59 | +| jca/SignatureOperation.java:94:16:94:38 | Key | KeyType | Asymmetric | jca/SignatureOperation.java:94:16:94:38 | jca/SignatureOperation.java:94:16:94:38 | +| jca/SignatureOperation.java:103:53:103:69 | HashAlgorithm | DigestSize | 256 | jca/SignatureOperation.java:103:53:103:69 | jca/SignatureOperation.java:103:53:103:69 | +| jca/SignatureOperation.java:103:53:103:69 | HashAlgorithm | Name | SHA2 | jca/SignatureOperation.java:103:53:103:69 | jca/SignatureOperation.java:103:53:103:69 | +| jca/SignatureOperation.java:103:53:103:69 | HashAlgorithm | RawName | SHA256withECDSA | jca/SignatureOperation.java:103:53:103:69 | jca/SignatureOperation.java:103:53:103:69 | +| jca/SignatureOperation.java:103:53:103:69 | KeyOperationAlgorithm | Name | ECDSA | jca/SignatureOperation.java:103:53:103:69 | jca/SignatureOperation.java:103:53:103:69 | +| jca/SignatureOperation.java:103:53:103:69 | KeyOperationAlgorithm | RawName | SHA256withECDSA | jca/SignatureOperation.java:103:53:103:69 | jca/SignatureOperation.java:103:53:103:69 | +| jca/SignatureOperation.java:104:28:104:37 | Key | KeyType | Unknown | jca/SignatureOperation.java:104:28:104:37 | jca/SignatureOperation.java:104:28:104:37 | +| jca/SignatureOperation.java:106:16:106:31 | SignOperation | KeyOperationSubtype | Sign | jca/SignatureOperation.java:106:16:106:31 | jca/SignatureOperation.java:106:16:106:31 | +| jca/SignatureOperation.java:115:53:115:69 | HashAlgorithm | DigestSize | 256 | jca/SignatureOperation.java:115:53:115:69 | jca/SignatureOperation.java:115:53:115:69 | +| jca/SignatureOperation.java:115:53:115:69 | HashAlgorithm | Name | SHA2 | jca/SignatureOperation.java:115:53:115:69 | jca/SignatureOperation.java:115:53:115:69 | +| jca/SignatureOperation.java:115:53:115:69 | HashAlgorithm | RawName | SHA256withECDSA | jca/SignatureOperation.java:115:53:115:69 | jca/SignatureOperation.java:115:53:115:69 | +| jca/SignatureOperation.java:115:53:115:69 | KeyOperationAlgorithm | Name | ECDSA | jca/SignatureOperation.java:115:53:115:69 | jca/SignatureOperation.java:115:53:115:69 | +| jca/SignatureOperation.java:115:53:115:69 | KeyOperationAlgorithm | RawName | SHA256withECDSA | jca/SignatureOperation.java:115:53:115:69 | jca/SignatureOperation.java:115:53:115:69 | +| jca/SignatureOperation.java:116:30:116:38 | Key | KeyType | Unknown | jca/SignatureOperation.java:116:30:116:38 | jca/SignatureOperation.java:116:30:116:38 | +| jca/SignatureOperation.java:118:16:118:41 | VerifyOperation | KeyOperationSubtype | Verify | jca/SignatureOperation.java:118:16:118:41 | jca/SignatureOperation.java:118:16:118:41 | +| jca/SignatureOperation.java:132:61:132:69 | Constant | Description | "Ed25519" | jca/SignatureOperation.java:132:61:132:69 | jca/SignatureOperation.java:132:61:132:69 | +| jca/SignatureOperation.java:133:16:133:36 | Key | KeyType | Asymmetric | jca/SignatureOperation.java:133:16:133:36 | jca/SignatureOperation.java:133:16:133:36 | +| jca/SignatureOperation.java:142:53:142:61 | KeyOperationAlgorithm | Name | EDSA | jca/SignatureOperation.java:142:53:142:61 | jca/SignatureOperation.java:142:53:142:61 | +| jca/SignatureOperation.java:142:53:142:61 | KeyOperationAlgorithm | RawName | Ed25519 | jca/SignatureOperation.java:142:53:142:61 | jca/SignatureOperation.java:142:53:142:61 | +| jca/SignatureOperation.java:143:28:143:37 | Key | KeyType | Unknown | jca/SignatureOperation.java:143:28:143:37 | jca/SignatureOperation.java:143:28:143:37 | +| jca/SignatureOperation.java:145:16:145:31 | SignOperation | KeyOperationSubtype | Sign | jca/SignatureOperation.java:145:16:145:31 | jca/SignatureOperation.java:145:16:145:31 | +| jca/SignatureOperation.java:154:53:154:61 | KeyOperationAlgorithm | Name | EDSA | jca/SignatureOperation.java:154:53:154:61 | jca/SignatureOperation.java:154:53:154:61 | +| jca/SignatureOperation.java:154:53:154:61 | KeyOperationAlgorithm | RawName | Ed25519 | jca/SignatureOperation.java:154:53:154:61 | jca/SignatureOperation.java:154:53:154:61 | +| jca/SignatureOperation.java:155:30:155:38 | Key | KeyType | Unknown | jca/SignatureOperation.java:155:30:155:38 | jca/SignatureOperation.java:155:30:155:38 | +| jca/SignatureOperation.java:157:16:157:41 | VerifyOperation | KeyOperationSubtype | Verify | jca/SignatureOperation.java:157:16:157:41 | jca/SignatureOperation.java:157:16:157:41 | +| jca/SignatureOperation.java:173:61:173:65 | KeyOperationAlgorithm | KeySize | Constant:1024 | jca/SignatureOperation.java:174:24:174:27 | jca/SignatureOperation.java:174:24:174:27 | +| jca/SignatureOperation.java:173:61:173:65 | KeyOperationAlgorithm | Name | RSA | jca/SignatureOperation.java:173:61:173:65 | jca/SignatureOperation.java:173:61:173:65 | +| jca/SignatureOperation.java:173:61:173:65 | KeyOperationAlgorithm | RawName | RSA | jca/SignatureOperation.java:173:61:173:65 | jca/SignatureOperation.java:173:61:173:65 | +| jca/SignatureOperation.java:174:24:174:27 | Constant | Description | 1024 | jca/SignatureOperation.java:174:24:174:27 | jca/SignatureOperation.java:174:24:174:27 | +| jca/SignatureOperation.java:175:16:175:36 | Key | KeyType | Asymmetric | jca/SignatureOperation.java:175:16:175:36 | jca/SignatureOperation.java:175:16:175:36 | +| jca/SignatureOperation.java:185:53:185:65 | HashAlgorithm | DigestSize | 160 | jca/SignatureOperation.java:185:53:185:65 | jca/SignatureOperation.java:185:53:185:65 | +| jca/SignatureOperation.java:185:53:185:65 | HashAlgorithm | Name | SHA1 | jca/SignatureOperation.java:185:53:185:65 | jca/SignatureOperation.java:185:53:185:65 | +| jca/SignatureOperation.java:185:53:185:65 | HashAlgorithm | RawName | SHA1withRSA | jca/SignatureOperation.java:185:53:185:65 | jca/SignatureOperation.java:185:53:185:65 | +| jca/SignatureOperation.java:185:53:185:65 | KeyOperationAlgorithm | Name | RSA | jca/SignatureOperation.java:185:53:185:65 | jca/SignatureOperation.java:185:53:185:65 | +| jca/SignatureOperation.java:185:53:185:65 | KeyOperationAlgorithm | RawName | SHA1withRSA | jca/SignatureOperation.java:185:53:185:65 | jca/SignatureOperation.java:185:53:185:65 | +| jca/SignatureOperation.java:186:28:186:37 | Key | KeyType | Unknown | jca/SignatureOperation.java:186:28:186:37 | jca/SignatureOperation.java:186:28:186:37 | +| jca/SignatureOperation.java:188:16:188:31 | SignOperation | KeyOperationSubtype | Sign | jca/SignatureOperation.java:188:16:188:31 | jca/SignatureOperation.java:188:16:188:31 | +| jca/SignatureOperation.java:198:53:198:65 | HashAlgorithm | DigestSize | 160 | jca/SignatureOperation.java:198:53:198:65 | jca/SignatureOperation.java:198:53:198:65 | +| jca/SignatureOperation.java:198:53:198:65 | HashAlgorithm | Name | SHA1 | jca/SignatureOperation.java:198:53:198:65 | jca/SignatureOperation.java:198:53:198:65 | +| jca/SignatureOperation.java:198:53:198:65 | HashAlgorithm | RawName | SHA1withRSA | jca/SignatureOperation.java:198:53:198:65 | jca/SignatureOperation.java:198:53:198:65 | +| jca/SignatureOperation.java:198:53:198:65 | KeyOperationAlgorithm | Name | RSA | jca/SignatureOperation.java:198:53:198:65 | jca/SignatureOperation.java:198:53:198:65 | +| jca/SignatureOperation.java:198:53:198:65 | KeyOperationAlgorithm | RawName | SHA1withRSA | jca/SignatureOperation.java:198:53:198:65 | jca/SignatureOperation.java:198:53:198:65 | +| jca/SignatureOperation.java:199:30:199:38 | Key | KeyType | Unknown | jca/SignatureOperation.java:199:30:199:38 | jca/SignatureOperation.java:199:30:199:38 | +| jca/SignatureOperation.java:201:16:201:41 | VerifyOperation | KeyOperationSubtype | Verify | jca/SignatureOperation.java:201:16:201:41 | jca/SignatureOperation.java:201:16:201:41 | +| jca/SignatureOperation.java:231:26:231:44 | Constant | Description | "Important Message" | jca/SignatureOperation.java:231:26:231:44 | jca/SignatureOperation.java:231:26:231:44 | +| jca/SignatureOperation.java:236:27:236:30 | Constant | Description | 0x01 | jca/SignatureOperation.java:236:27:236:30 | jca/SignatureOperation.java:236:27:236:30 | +| jca/SignatureOperation.java:266:47:266:68 | HashAlgorithm | DigestSize | 256 | jca/SignatureOperation.java:266:47:266:68 | jca/SignatureOperation.java:266:47:266:68 | +| jca/SignatureOperation.java:266:47:266:68 | HashAlgorithm | Name | SHA2 | jca/SignatureOperation.java:266:47:266:68 | jca/SignatureOperation.java:266:47:266:68 | +| jca/SignatureOperation.java:266:47:266:68 | HashAlgorithm | RawName | SHA256withRSAandMGF1 | jca/SignatureOperation.java:266:47:266:68 | jca/SignatureOperation.java:266:47:266:68 | +| jca/SignatureOperation.java:266:47:266:68 | KeyOperationAlgorithm | Name | RSA | jca/SignatureOperation.java:266:47:266:68 | jca/SignatureOperation.java:266:47:266:68 | +| jca/SignatureOperation.java:266:47:266:68 | KeyOperationAlgorithm | RawName | SHA256withRSAandMGF1 | jca/SignatureOperation.java:266:47:266:68 | jca/SignatureOperation.java:266:47:266:68 | +| jca/SignatureOperation.java:269:47:269:63 | HashAlgorithm | DigestSize | 256 | jca/SignatureOperation.java:269:47:269:63 | jca/SignatureOperation.java:269:47:269:63 | +| jca/SignatureOperation.java:269:47:269:63 | HashAlgorithm | Name | SHA2 | jca/SignatureOperation.java:269:47:269:63 | jca/SignatureOperation.java:269:47:269:63 | +| jca/SignatureOperation.java:269:47:269:63 | HashAlgorithm | RawName | SHA256withECDSA | jca/SignatureOperation.java:269:47:269:63 | jca/SignatureOperation.java:269:47:269:63 | +| jca/SignatureOperation.java:269:47:269:63 | KeyOperationAlgorithm | Name | ECDSA | jca/SignatureOperation.java:269:47:269:63 | jca/SignatureOperation.java:269:47:269:63 | +| jca/SignatureOperation.java:269:47:269:63 | KeyOperationAlgorithm | RawName | SHA256withECDSA | jca/SignatureOperation.java:269:47:269:63 | jca/SignatureOperation.java:269:47:269:63 | +| jca/SignatureOperation.java:272:47:272:55 | KeyOperationAlgorithm | Name | EDSA | jca/SignatureOperation.java:272:47:272:55 | jca/SignatureOperation.java:272:47:272:55 | +| jca/SignatureOperation.java:272:47:272:55 | KeyOperationAlgorithm | RawName | Ed25519 | jca/SignatureOperation.java:272:47:272:55 | jca/SignatureOperation.java:272:47:272:55 | +| jca/SignatureOperation.java:275:47:275:59 | HashAlgorithm | DigestSize | 160 | jca/SignatureOperation.java:275:47:275:59 | jca/SignatureOperation.java:275:47:275:59 | +| jca/SignatureOperation.java:275:47:275:59 | HashAlgorithm | Name | SHA1 | jca/SignatureOperation.java:275:47:275:59 | jca/SignatureOperation.java:275:47:275:59 | +| jca/SignatureOperation.java:275:47:275:59 | HashAlgorithm | RawName | SHA1withRSA | jca/SignatureOperation.java:275:47:275:59 | jca/SignatureOperation.java:275:47:275:59 | +| jca/SignatureOperation.java:275:47:275:59 | KeyOperationAlgorithm | Name | RSA | jca/SignatureOperation.java:275:47:275:59 | jca/SignatureOperation.java:275:47:275:59 | +| jca/SignatureOperation.java:275:47:275:59 | KeyOperationAlgorithm | RawName | SHA1withRSA | jca/SignatureOperation.java:275:47:275:59 | jca/SignatureOperation.java:275:47:275:59 | +| jca/SignatureOperation.java:279:47:279:68 | HashAlgorithm | DigestSize | 256 | jca/SignatureOperation.java:279:47:279:68 | jca/SignatureOperation.java:279:47:279:68 | +| jca/SignatureOperation.java:279:47:279:68 | HashAlgorithm | Name | SHA2 | jca/SignatureOperation.java:279:47:279:68 | jca/SignatureOperation.java:279:47:279:68 | +| jca/SignatureOperation.java:279:47:279:68 | HashAlgorithm | RawName | SHA256withRSAandMGF1 | jca/SignatureOperation.java:279:47:279:68 | jca/SignatureOperation.java:279:47:279:68 | +| jca/SignatureOperation.java:279:47:279:68 | KeyOperationAlgorithm | Name | RSA | jca/SignatureOperation.java:279:47:279:68 | jca/SignatureOperation.java:279:47:279:68 | +| jca/SignatureOperation.java:279:47:279:68 | KeyOperationAlgorithm | RawName | SHA256withRSAandMGF1 | jca/SignatureOperation.java:279:47:279:68 | jca/SignatureOperation.java:279:47:279:68 | +| jca/SignatureOperation.java:282:26:282:49 | Constant | Description | "Dynamic Signature Demo" | jca/SignatureOperation.java:282:26:282:49 | jca/SignatureOperation.java:282:26:282:49 | +| jca/SignatureOperation.java:283:28:283:42 | Key | KeyType | Unknown | jca/SignatureOperation.java:283:28:283:42 | jca/SignatureOperation.java:283:28:283:42 | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | KeyOperationSubtype | Sign | jca/SignatureOperation.java:285:27:285:42 | jca/SignatureOperation.java:285:27:285:42 | +| jca/SignatureOperation.java:287:30:287:43 | Key | KeyType | Unknown | jca/SignatureOperation.java:287:30:287:43 | jca/SignatureOperation.java:287:30:287:43 | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | KeyOperationSubtype | Verify | jca/SignatureOperation.java:289:28:289:53 | jca/SignatureOperation.java:289:28:289:53 | +| jca/SignatureOperation.java:311:26:311:49 | Constant | Description | "Hello Signature World!" | jca/SignatureOperation.java:311:26:311:49 | jca/SignatureOperation.java:311:26:311:49 | +| jca/SymmetricAlgorithm.java:51:44:51:62 | KeyOperationAlgorithm | Name | AES | jca/SymmetricAlgorithm.java:51:44:51:62 | jca/SymmetricAlgorithm.java:51:44:51:62 | +| jca/SymmetricAlgorithm.java:51:44:51:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/SymmetricAlgorithm.java:51:44:51:62 | jca/SymmetricAlgorithm.java:51:44:51:62 | +| jca/SymmetricAlgorithm.java:51:44:51:62 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricAlgorithm.java:51:44:51:62 | jca/SymmetricAlgorithm.java:51:44:51:62 | +| jca/SymmetricAlgorithm.java:51:44:51:62 | ModeOfOperation | Name | GCM | jca/SymmetricAlgorithm.java:51:44:51:62 | jca/SymmetricAlgorithm.java:51:44:51:62 | +| jca/SymmetricAlgorithm.java:51:44:51:62 | ModeOfOperation | RawName | GCM | jca/SymmetricAlgorithm.java:51:44:51:62 | jca/SymmetricAlgorithm.java:51:44:51:62 | +| jca/SymmetricAlgorithm.java:51:44:51:62 | PaddingAlgorithm | Name | UnknownPadding | jca/SymmetricAlgorithm.java:51:44:51:62 | jca/SymmetricAlgorithm.java:51:44:51:62 | +| jca/SymmetricAlgorithm.java:51:44:51:62 | PaddingAlgorithm | RawName | NoPadding | jca/SymmetricAlgorithm.java:51:44:51:62 | jca/SymmetricAlgorithm.java:51:44:51:62 | +| jca/SymmetricAlgorithm.java:53:9:53:40 | RandomNumberGeneration | Description | nextBytes | jca/SymmetricAlgorithm.java:53:9:53:40 | jca/SymmetricAlgorithm.java:53:9:53:40 | +| jca/SymmetricAlgorithm.java:53:38:53:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SymmetricAlgorithm.java:53:38:53:39 | jca/SymmetricAlgorithm.java:53:38:53:39 | +| jca/SymmetricAlgorithm.java:55:42:55:44 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:55:42:55:44 | jca/SymmetricAlgorithm.java:55:42:55:44 | +| jca/SymmetricAlgorithm.java:56:29:56:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:56:29:56:53 | jca/SymmetricAlgorithm.java:56:29:56:53 | +| jca/SymmetricAlgorithm.java:72:39:72:51 | Parameter | Description | key | jca/SymmetricAlgorithm.java:72:39:72:51 | jca/SymmetricAlgorithm.java:72:39:72:51 | +| jca/SymmetricAlgorithm.java:72:54:72:69 | Parameter | Description | plaintext | jca/SymmetricAlgorithm.java:72:54:72:69 | jca/SymmetricAlgorithm.java:72:54:72:69 | +| jca/SymmetricAlgorithm.java:73:44:73:62 | KeyOperationAlgorithm | Name | AES | jca/SymmetricAlgorithm.java:73:44:73:62 | jca/SymmetricAlgorithm.java:73:44:73:62 | +| jca/SymmetricAlgorithm.java:73:44:73:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/SymmetricAlgorithm.java:73:44:73:62 | jca/SymmetricAlgorithm.java:73:44:73:62 | +| jca/SymmetricAlgorithm.java:73:44:73:62 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricAlgorithm.java:73:44:73:62 | jca/SymmetricAlgorithm.java:73:44:73:62 | +| jca/SymmetricAlgorithm.java:73:44:73:62 | ModeOfOperation | Name | GCM | jca/SymmetricAlgorithm.java:73:44:73:62 | jca/SymmetricAlgorithm.java:73:44:73:62 | +| jca/SymmetricAlgorithm.java:73:44:73:62 | ModeOfOperation | RawName | GCM | jca/SymmetricAlgorithm.java:73:44:73:62 | jca/SymmetricAlgorithm.java:73:44:73:62 | +| jca/SymmetricAlgorithm.java:73:44:73:62 | PaddingAlgorithm | Name | UnknownPadding | jca/SymmetricAlgorithm.java:73:44:73:62 | jca/SymmetricAlgorithm.java:73:44:73:62 | +| jca/SymmetricAlgorithm.java:73:44:73:62 | PaddingAlgorithm | RawName | NoPadding | jca/SymmetricAlgorithm.java:73:44:73:62 | jca/SymmetricAlgorithm.java:73:44:73:62 | +| jca/SymmetricAlgorithm.java:76:42:76:44 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:76:42:76:44 | jca/SymmetricAlgorithm.java:76:42:76:44 | +| jca/SymmetricAlgorithm.java:77:29:77:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:77:29:77:53 | jca/SymmetricAlgorithm.java:77:29:77:53 | +| jca/SymmetricAlgorithm.java:94:44:94:65 | KeyOperationAlgorithm | Name | AES | jca/SymmetricAlgorithm.java:94:44:94:65 | jca/SymmetricAlgorithm.java:94:44:94:65 | +| jca/SymmetricAlgorithm.java:94:44:94:65 | KeyOperationAlgorithm | RawName | AES/CBC/PKCS5Padding | jca/SymmetricAlgorithm.java:94:44:94:65 | jca/SymmetricAlgorithm.java:94:44:94:65 | +| jca/SymmetricAlgorithm.java:94:44:94:65 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricAlgorithm.java:94:44:94:65 | jca/SymmetricAlgorithm.java:94:44:94:65 | +| jca/SymmetricAlgorithm.java:94:44:94:65 | ModeOfOperation | Name | CBC | jca/SymmetricAlgorithm.java:94:44:94:65 | jca/SymmetricAlgorithm.java:94:44:94:65 | +| jca/SymmetricAlgorithm.java:94:44:94:65 | ModeOfOperation | RawName | CBC | jca/SymmetricAlgorithm.java:94:44:94:65 | jca/SymmetricAlgorithm.java:94:44:94:65 | +| jca/SymmetricAlgorithm.java:94:44:94:65 | PaddingAlgorithm | Name | PKCS7 | jca/SymmetricAlgorithm.java:94:44:94:65 | jca/SymmetricAlgorithm.java:94:44:94:65 | +| jca/SymmetricAlgorithm.java:94:44:94:65 | PaddingAlgorithm | RawName | PKCS5Padding | jca/SymmetricAlgorithm.java:94:44:94:65 | jca/SymmetricAlgorithm.java:94:44:94:65 | +| jca/SymmetricAlgorithm.java:96:9:96:40 | RandomNumberGeneration | Description | nextBytes | jca/SymmetricAlgorithm.java:96:9:96:40 | jca/SymmetricAlgorithm.java:96:9:96:40 | +| jca/SymmetricAlgorithm.java:96:38:96:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SymmetricAlgorithm.java:96:38:96:39 | jca/SymmetricAlgorithm.java:96:38:96:39 | +| jca/SymmetricAlgorithm.java:98:42:98:44 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:98:42:98:44 | jca/SymmetricAlgorithm.java:98:42:98:44 | +| jca/SymmetricAlgorithm.java:99:29:99:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:99:29:99:53 | jca/SymmetricAlgorithm.java:99:29:99:53 | +| jca/SymmetricAlgorithm.java:116:44:116:65 | KeyOperationAlgorithm | Name | AES | jca/SymmetricAlgorithm.java:116:44:116:65 | jca/SymmetricAlgorithm.java:116:44:116:65 | +| jca/SymmetricAlgorithm.java:116:44:116:65 | KeyOperationAlgorithm | RawName | AES/ECB/PKCS5Padding | jca/SymmetricAlgorithm.java:116:44:116:65 | jca/SymmetricAlgorithm.java:116:44:116:65 | +| jca/SymmetricAlgorithm.java:116:44:116:65 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricAlgorithm.java:116:44:116:65 | jca/SymmetricAlgorithm.java:116:44:116:65 | +| jca/SymmetricAlgorithm.java:116:44:116:65 | ModeOfOperation | Name | ECB | jca/SymmetricAlgorithm.java:116:44:116:65 | jca/SymmetricAlgorithm.java:116:44:116:65 | +| jca/SymmetricAlgorithm.java:116:44:116:65 | ModeOfOperation | RawName | ECB | jca/SymmetricAlgorithm.java:116:44:116:65 | jca/SymmetricAlgorithm.java:116:44:116:65 | +| jca/SymmetricAlgorithm.java:116:44:116:65 | PaddingAlgorithm | Name | PKCS7 | jca/SymmetricAlgorithm.java:116:44:116:65 | jca/SymmetricAlgorithm.java:116:44:116:65 | +| jca/SymmetricAlgorithm.java:116:44:116:65 | PaddingAlgorithm | RawName | PKCS5Padding | jca/SymmetricAlgorithm.java:116:44:116:65 | jca/SymmetricAlgorithm.java:116:44:116:65 | +| jca/SymmetricAlgorithm.java:117:42:117:44 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:117:42:117:44 | jca/SymmetricAlgorithm.java:117:42:117:44 | +| jca/SymmetricAlgorithm.java:118:16:118:40 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:118:16:118:40 | jca/SymmetricAlgorithm.java:118:16:118:40 | +| jca/SymmetricAlgorithm.java:131:44:131:48 | KeyOperationAlgorithm | Name | RC4 | jca/SymmetricAlgorithm.java:131:44:131:48 | jca/SymmetricAlgorithm.java:131:44:131:48 | +| jca/SymmetricAlgorithm.java:131:44:131:48 | KeyOperationAlgorithm | RawName | RC4 | jca/SymmetricAlgorithm.java:131:44:131:48 | jca/SymmetricAlgorithm.java:131:44:131:48 | +| jca/SymmetricAlgorithm.java:131:44:131:48 | KeyOperationAlgorithm | Structure | Stream | jca/SymmetricAlgorithm.java:131:44:131:48 | jca/SymmetricAlgorithm.java:131:44:131:48 | +| jca/SymmetricAlgorithm.java:132:42:132:44 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:132:42:132:44 | jca/SymmetricAlgorithm.java:132:42:132:44 | +| jca/SymmetricAlgorithm.java:133:16:133:40 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:133:16:133:40 | jca/SymmetricAlgorithm.java:133:16:133:40 | +| jca/SymmetricAlgorithm.java:145:36:145:48 | Parameter | Description | key | jca/SymmetricAlgorithm.java:145:36:145:48 | jca/SymmetricAlgorithm.java:145:36:145:48 | +| jca/SymmetricAlgorithm.java:145:51:145:66 | Parameter | Description | plaintext | jca/SymmetricAlgorithm.java:145:51:145:66 | jca/SymmetricAlgorithm.java:145:51:145:66 | +| jca/SymmetricAlgorithm.java:146:44:146:65 | KeyOperationAlgorithm | KeySize | 56 | jca/SymmetricAlgorithm.java:146:44:146:65 | jca/SymmetricAlgorithm.java:146:44:146:65 | +| jca/SymmetricAlgorithm.java:146:44:146:65 | KeyOperationAlgorithm | Name | DES | jca/SymmetricAlgorithm.java:146:44:146:65 | jca/SymmetricAlgorithm.java:146:44:146:65 | +| jca/SymmetricAlgorithm.java:146:44:146:65 | KeyOperationAlgorithm | RawName | DES/CBC/PKCS5Padding | jca/SymmetricAlgorithm.java:146:44:146:65 | jca/SymmetricAlgorithm.java:146:44:146:65 | +| jca/SymmetricAlgorithm.java:146:44:146:65 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricAlgorithm.java:146:44:146:65 | jca/SymmetricAlgorithm.java:146:44:146:65 | +| jca/SymmetricAlgorithm.java:146:44:146:65 | ModeOfOperation | Name | CBC | jca/SymmetricAlgorithm.java:146:44:146:65 | jca/SymmetricAlgorithm.java:146:44:146:65 | +| jca/SymmetricAlgorithm.java:146:44:146:65 | ModeOfOperation | RawName | CBC | jca/SymmetricAlgorithm.java:146:44:146:65 | jca/SymmetricAlgorithm.java:146:44:146:65 | +| jca/SymmetricAlgorithm.java:146:44:146:65 | PaddingAlgorithm | Name | PKCS7 | jca/SymmetricAlgorithm.java:146:44:146:65 | jca/SymmetricAlgorithm.java:146:44:146:65 | +| jca/SymmetricAlgorithm.java:146:44:146:65 | PaddingAlgorithm | RawName | PKCS5Padding | jca/SymmetricAlgorithm.java:146:44:146:65 | jca/SymmetricAlgorithm.java:146:44:146:65 | +| jca/SymmetricAlgorithm.java:148:9:148:40 | RandomNumberGeneration | Description | nextBytes | jca/SymmetricAlgorithm.java:148:9:148:40 | jca/SymmetricAlgorithm.java:148:9:148:40 | +| jca/SymmetricAlgorithm.java:148:38:148:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SymmetricAlgorithm.java:148:38:148:39 | jca/SymmetricAlgorithm.java:148:38:148:39 | +| jca/SymmetricAlgorithm.java:150:42:150:44 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:150:42:150:44 | jca/SymmetricAlgorithm.java:150:42:150:44 | +| jca/SymmetricAlgorithm.java:151:29:151:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:151:29:151:53 | jca/SymmetricAlgorithm.java:151:29:151:53 | +| jca/SymmetricAlgorithm.java:167:42:167:54 | Parameter | Description | key | jca/SymmetricAlgorithm.java:167:42:167:54 | jca/SymmetricAlgorithm.java:167:42:167:54 | +| jca/SymmetricAlgorithm.java:167:57:167:72 | Parameter | Description | plaintext | jca/SymmetricAlgorithm.java:167:57:167:72 | jca/SymmetricAlgorithm.java:167:57:167:72 | +| jca/SymmetricAlgorithm.java:168:44:168:68 | KeyOperationAlgorithm | Name | Unknown | jca/SymmetricAlgorithm.java:168:44:168:68 | jca/SymmetricAlgorithm.java:168:44:168:68 | +| jca/SymmetricAlgorithm.java:168:44:168:68 | KeyOperationAlgorithm | RawName | DESede/CBC/PKCS5Padding | jca/SymmetricAlgorithm.java:168:44:168:68 | jca/SymmetricAlgorithm.java:168:44:168:68 | +| jca/SymmetricAlgorithm.java:168:44:168:68 | ModeOfOperation | Name | CBC | jca/SymmetricAlgorithm.java:168:44:168:68 | jca/SymmetricAlgorithm.java:168:44:168:68 | +| jca/SymmetricAlgorithm.java:168:44:168:68 | ModeOfOperation | RawName | CBC | jca/SymmetricAlgorithm.java:168:44:168:68 | jca/SymmetricAlgorithm.java:168:44:168:68 | +| jca/SymmetricAlgorithm.java:168:44:168:68 | PaddingAlgorithm | Name | PKCS7 | jca/SymmetricAlgorithm.java:168:44:168:68 | jca/SymmetricAlgorithm.java:168:44:168:68 | +| jca/SymmetricAlgorithm.java:168:44:168:68 | PaddingAlgorithm | RawName | PKCS5Padding | jca/SymmetricAlgorithm.java:168:44:168:68 | jca/SymmetricAlgorithm.java:168:44:168:68 | +| jca/SymmetricAlgorithm.java:170:9:170:40 | RandomNumberGeneration | Description | nextBytes | jca/SymmetricAlgorithm.java:170:9:170:40 | jca/SymmetricAlgorithm.java:170:9:170:40 | +| jca/SymmetricAlgorithm.java:170:38:170:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SymmetricAlgorithm.java:170:38:170:39 | jca/SymmetricAlgorithm.java:170:38:170:39 | +| jca/SymmetricAlgorithm.java:172:42:172:44 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:172:42:172:44 | jca/SymmetricAlgorithm.java:172:42:172:44 | +| jca/SymmetricAlgorithm.java:173:29:173:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:173:29:173:53 | jca/SymmetricAlgorithm.java:173:29:173:53 | +| jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | KeySize | 256 | jca/SymmetricAlgorithm.java:190:44:190:53 | jca/SymmetricAlgorithm.java:190:44:190:53 | +| jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | Name | ChaCha20 | jca/SymmetricAlgorithm.java:190:44:190:53 | jca/SymmetricAlgorithm.java:190:44:190:53 | +| jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | RawName | ChaCha20 | jca/SymmetricAlgorithm.java:190:44:190:53 | jca/SymmetricAlgorithm.java:190:44:190:53 | +| jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | Structure | Stream | jca/SymmetricAlgorithm.java:190:44:190:53 | jca/SymmetricAlgorithm.java:190:44:190:53 | +| jca/SymmetricAlgorithm.java:192:9:192:43 | RandomNumberGeneration | Description | nextBytes | jca/SymmetricAlgorithm.java:192:9:192:43 | jca/SymmetricAlgorithm.java:192:9:192:43 | +| jca/SymmetricAlgorithm.java:192:38:192:42 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SymmetricAlgorithm.java:192:38:192:42 | jca/SymmetricAlgorithm.java:192:38:192:42 | +| jca/SymmetricAlgorithm.java:194:42:194:44 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:194:42:194:44 | jca/SymmetricAlgorithm.java:194:42:194:44 | +| jca/SymmetricAlgorithm.java:195:29:195:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:195:29:195:53 | jca/SymmetricAlgorithm.java:195:29:195:53 | +| jca/SymmetricAlgorithm.java:212:35:212:47 | Parameter | Description | key | jca/SymmetricAlgorithm.java:212:35:212:47 | jca/SymmetricAlgorithm.java:212:35:212:47 | +| jca/SymmetricAlgorithm.java:212:50:212:65 | Parameter | Description | plaintext | jca/SymmetricAlgorithm.java:212:50:212:65 | jca/SymmetricAlgorithm.java:212:50:212:65 | +| jca/SymmetricAlgorithm.java:213:36:213:44 | Constant | Description | "KMAC128" | jca/SymmetricAlgorithm.java:213:36:213:44 | jca/SymmetricAlgorithm.java:213:36:213:44 | +| jca/SymmetricAlgorithm.java:214:19:214:21 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:214:19:214:21 | jca/SymmetricAlgorithm.java:214:19:214:21 | +| jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | KeyOperationSubtype | Mac | jca/SymmetricAlgorithm.java:215:29:215:51 | jca/SymmetricAlgorithm.java:215:29:215:51 | +| jca/SymmetricAlgorithm.java:218:44:218:62 | KeyOperationAlgorithm | Name | AES | jca/SymmetricAlgorithm.java:218:44:218:62 | jca/SymmetricAlgorithm.java:218:44:218:62 | +| jca/SymmetricAlgorithm.java:218:44:218:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/SymmetricAlgorithm.java:218:44:218:62 | jca/SymmetricAlgorithm.java:218:44:218:62 | +| jca/SymmetricAlgorithm.java:218:44:218:62 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricAlgorithm.java:218:44:218:62 | jca/SymmetricAlgorithm.java:218:44:218:62 | +| jca/SymmetricAlgorithm.java:218:44:218:62 | ModeOfOperation | Name | GCM | jca/SymmetricAlgorithm.java:218:44:218:62 | jca/SymmetricAlgorithm.java:218:44:218:62 | +| jca/SymmetricAlgorithm.java:218:44:218:62 | ModeOfOperation | RawName | GCM | jca/SymmetricAlgorithm.java:218:44:218:62 | jca/SymmetricAlgorithm.java:218:44:218:62 | +| jca/SymmetricAlgorithm.java:218:44:218:62 | PaddingAlgorithm | Name | UnknownPadding | jca/SymmetricAlgorithm.java:218:44:218:62 | jca/SymmetricAlgorithm.java:218:44:218:62 | +| jca/SymmetricAlgorithm.java:218:44:218:62 | PaddingAlgorithm | RawName | NoPadding | jca/SymmetricAlgorithm.java:218:44:218:62 | jca/SymmetricAlgorithm.java:218:44:218:62 | +| jca/SymmetricAlgorithm.java:220:9:220:40 | RandomNumberGeneration | Description | nextBytes | jca/SymmetricAlgorithm.java:220:9:220:40 | jca/SymmetricAlgorithm.java:220:9:220:40 | +| jca/SymmetricAlgorithm.java:220:38:220:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SymmetricAlgorithm.java:220:38:220:39 | jca/SymmetricAlgorithm.java:220:38:220:39 | +| jca/SymmetricAlgorithm.java:222:42:222:51 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:222:42:222:51 | jca/SymmetricAlgorithm.java:222:42:222:51 | +| jca/SymmetricAlgorithm.java:223:29:223:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:223:29:223:53 | jca/SymmetricAlgorithm.java:223:29:223:53 | +| jca/SymmetricAlgorithm.java:244:64:244:76 | Parameter | Description | key | jca/SymmetricAlgorithm.java:244:64:244:76 | jca/SymmetricAlgorithm.java:244:64:244:76 | +| jca/SymmetricAlgorithm.java:244:79:244:94 | Parameter | Description | plaintext | jca/SymmetricAlgorithm.java:244:79:244:94 | jca/SymmetricAlgorithm.java:244:79:244:94 | +| jca/SymmetricAlgorithm.java:284:58:284:70 | Parameter | Description | key | jca/SymmetricAlgorithm.java:284:58:284:70 | jca/SymmetricAlgorithm.java:284:58:284:70 | +| jca/SymmetricAlgorithm.java:284:73:284:88 | Parameter | Description | plaintext | jca/SymmetricAlgorithm.java:284:73:284:88 | jca/SymmetricAlgorithm.java:284:73:284:88 | +| jca/SymmetricAlgorithm.java:287:75:287:79 | Constant | Description | 10000 | jca/SymmetricAlgorithm.java:287:75:287:79 | jca/SymmetricAlgorithm.java:287:75:287:79 | +| jca/SymmetricAlgorithm.java:287:82:287:84 | Constant | Description | 256 | jca/SymmetricAlgorithm.java:287:82:287:84 | jca/SymmetricAlgorithm.java:287:82:287:84 | +| jca/SymmetricAlgorithm.java:288:65:288:86 | HMACAlgorithm | Name | HMAC | jca/SymmetricAlgorithm.java:288:65:288:86 | jca/SymmetricAlgorithm.java:288:65:288:86 | +| jca/SymmetricAlgorithm.java:288:65:288:86 | HMACAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/SymmetricAlgorithm.java:288:65:288:86 | jca/SymmetricAlgorithm.java:288:65:288:86 | +| jca/SymmetricAlgorithm.java:288:65:288:86 | HashAlgorithm | DigestSize | 256 | jca/SymmetricAlgorithm.java:288:65:288:86 | jca/SymmetricAlgorithm.java:288:65:288:86 | +| jca/SymmetricAlgorithm.java:288:65:288:86 | HashAlgorithm | Name | SHA2 | jca/SymmetricAlgorithm.java:288:65:288:86 | jca/SymmetricAlgorithm.java:288:65:288:86 | +| jca/SymmetricAlgorithm.java:288:65:288:86 | HashAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/SymmetricAlgorithm.java:288:65:288:86 | jca/SymmetricAlgorithm.java:288:65:288:86 | +| jca/SymmetricAlgorithm.java:288:65:288:86 | KeyDerivationAlgorithm | Name | PBKDF2WithHmacSHA256 | jca/SymmetricAlgorithm.java:288:65:288:86 | jca/SymmetricAlgorithm.java:288:65:288:86 | +| jca/SymmetricAlgorithm.java:288:65:288:86 | KeyDerivationAlgorithm | RawName | PBKDF2WithHmacSHA256 | jca/SymmetricAlgorithm.java:288:65:288:86 | jca/SymmetricAlgorithm.java:288:65:288:86 | +| jca/SymmetricAlgorithm.java:289:26:289:53 | Key | KeyType | Symmetric | jca/SymmetricAlgorithm.java:289:26:289:53 | jca/SymmetricAlgorithm.java:289:26:289:53 | +| jca/SymmetricAlgorithm.java:289:26:289:53 | KeyDerivation | Iterations | Constant:10000 | jca/SymmetricAlgorithm.java:287:75:287:79 | jca/SymmetricAlgorithm.java:287:75:287:79 | +| jca/SymmetricAlgorithm.java:289:26:289:53 | KeyDerivation | KeySize | Constant:256 | jca/SymmetricAlgorithm.java:287:82:287:84 | jca/SymmetricAlgorithm.java:287:82:287:84 | +| jca/SymmetricAlgorithm.java:295:44:295:62 | KeyOperationAlgorithm | Name | AES | jca/SymmetricAlgorithm.java:295:44:295:62 | jca/SymmetricAlgorithm.java:295:44:295:62 | +| jca/SymmetricAlgorithm.java:295:44:295:62 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/SymmetricAlgorithm.java:295:44:295:62 | jca/SymmetricAlgorithm.java:295:44:295:62 | +| jca/SymmetricAlgorithm.java:295:44:295:62 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricAlgorithm.java:295:44:295:62 | jca/SymmetricAlgorithm.java:295:44:295:62 | +| jca/SymmetricAlgorithm.java:295:44:295:62 | ModeOfOperation | Name | GCM | jca/SymmetricAlgorithm.java:295:44:295:62 | jca/SymmetricAlgorithm.java:295:44:295:62 | +| jca/SymmetricAlgorithm.java:295:44:295:62 | ModeOfOperation | RawName | GCM | jca/SymmetricAlgorithm.java:295:44:295:62 | jca/SymmetricAlgorithm.java:295:44:295:62 | +| jca/SymmetricAlgorithm.java:295:44:295:62 | PaddingAlgorithm | Name | UnknownPadding | jca/SymmetricAlgorithm.java:295:44:295:62 | jca/SymmetricAlgorithm.java:295:44:295:62 | +| jca/SymmetricAlgorithm.java:295:44:295:62 | PaddingAlgorithm | RawName | NoPadding | jca/SymmetricAlgorithm.java:295:44:295:62 | jca/SymmetricAlgorithm.java:295:44:295:62 | +| jca/SymmetricAlgorithm.java:297:9:297:40 | RandomNumberGeneration | Description | nextBytes | jca/SymmetricAlgorithm.java:297:9:297:40 | jca/SymmetricAlgorithm.java:297:9:297:40 | +| jca/SymmetricAlgorithm.java:297:38:297:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SymmetricAlgorithm.java:297:38:297:39 | jca/SymmetricAlgorithm.java:297:38:297:39 | +| jca/SymmetricAlgorithm.java:298:42:298:47 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:298:42:298:47 | jca/SymmetricAlgorithm.java:298:42:298:47 | +| jca/SymmetricAlgorithm.java:299:29:299:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricAlgorithm.java:299:29:299:53 | jca/SymmetricAlgorithm.java:299:29:299:53 | +| jca/SymmetricAlgorithm.java:301:35:301:46 | KeyOperationAlgorithm | Name | HMAC | jca/SymmetricAlgorithm.java:301:35:301:46 | jca/SymmetricAlgorithm.java:301:35:301:46 | +| jca/SymmetricAlgorithm.java:301:35:301:46 | KeyOperationAlgorithm | RawName | HmacSHA256 | jca/SymmetricAlgorithm.java:301:35:301:46 | jca/SymmetricAlgorithm.java:301:35:301:46 | +| jca/SymmetricAlgorithm.java:302:18:302:30 | Key | KeyType | Unknown | jca/SymmetricAlgorithm.java:302:18:302:30 | jca/SymmetricAlgorithm.java:302:18:302:30 | +| jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | KeyOperationSubtype | Mac | jca/SymmetricAlgorithm.java:303:30:303:52 | jca/SymmetricAlgorithm.java:303:30:303:52 | +| jca/SymmetricAlgorithm.java:331:52:331:56 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/SymmetricAlgorithm.java:332:17:332:19 | jca/SymmetricAlgorithm.java:332:17:332:19 | +| jca/SymmetricAlgorithm.java:331:52:331:56 | KeyOperationAlgorithm | Name | AES | jca/SymmetricAlgorithm.java:331:52:331:56 | jca/SymmetricAlgorithm.java:331:52:331:56 | +| jca/SymmetricAlgorithm.java:331:52:331:56 | KeyOperationAlgorithm | RawName | AES | jca/SymmetricAlgorithm.java:331:52:331:56 | jca/SymmetricAlgorithm.java:331:52:331:56 | +| jca/SymmetricAlgorithm.java:331:52:331:56 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricAlgorithm.java:331:52:331:56 | jca/SymmetricAlgorithm.java:331:52:331:56 | +| jca/SymmetricAlgorithm.java:332:17:332:19 | Constant | Description | 256 | jca/SymmetricAlgorithm.java:332:17:332:19 | jca/SymmetricAlgorithm.java:332:17:332:19 | +| jca/SymmetricAlgorithm.java:333:16:333:31 | Key | KeyType | Symmetric | jca/SymmetricAlgorithm.java:333:16:333:31 | jca/SymmetricAlgorithm.java:333:16:333:31 | +| jca/SymmetricAlgorithm.java:345:9:345:42 | RandomNumberGeneration | Description | nextBytes | jca/SymmetricAlgorithm.java:345:9:345:42 | jca/SymmetricAlgorithm.java:345:9:345:42 | +| jca/SymmetricAlgorithm.java:345:38:345:41 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SymmetricAlgorithm.java:345:38:345:41 | jca/SymmetricAlgorithm.java:345:38:345:41 | +| jca/SymmetricModesTest.java:48:52:48:56 | KeyOperationAlgorithm | KeySize | Constant:128 | jca/SymmetricModesTest.java:53:17:53:19 | jca/SymmetricModesTest.java:53:17:53:19 | +| jca/SymmetricModesTest.java:48:52:48:56 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/SymmetricModesTest.java:49:17:49:19 | jca/SymmetricModesTest.java:49:17:49:19 | +| jca/SymmetricModesTest.java:48:52:48:56 | KeyOperationAlgorithm | Name | AES | jca/SymmetricModesTest.java:48:52:48:56 | jca/SymmetricModesTest.java:48:52:48:56 | +| jca/SymmetricModesTest.java:48:52:48:56 | KeyOperationAlgorithm | RawName | AES | jca/SymmetricModesTest.java:48:52:48:56 | jca/SymmetricModesTest.java:48:52:48:56 | +| jca/SymmetricModesTest.java:48:52:48:56 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricModesTest.java:48:52:48:56 | jca/SymmetricModesTest.java:48:52:48:56 | +| jca/SymmetricModesTest.java:49:17:49:19 | Constant | Description | 256 | jca/SymmetricModesTest.java:49:17:49:19 | jca/SymmetricModesTest.java:49:17:49:19 | +| jca/SymmetricModesTest.java:50:33:50:48 | Key | KeyType | Symmetric | jca/SymmetricModesTest.java:50:33:50:48 | jca/SymmetricModesTest.java:50:33:50:48 | +| jca/SymmetricModesTest.java:53:17:53:19 | Constant | Description | 128 | jca/SymmetricModesTest.java:53:17:53:19 | jca/SymmetricModesTest.java:53:17:53:19 | +| jca/SymmetricModesTest.java:54:31:54:46 | Key | KeyType | Symmetric | jca/SymmetricModesTest.java:54:31:54:46 | jca/SymmetricModesTest.java:54:31:54:46 | +| jca/SymmetricModesTest.java:57:44:57:62 | KeyOperationAlgorithm | Name | AES | jca/SymmetricModesTest.java:57:44:57:62 | jca/SymmetricModesTest.java:57:44:57:62 | +| jca/SymmetricModesTest.java:57:44:57:62 | KeyOperationAlgorithm | RawName | AES/KWP/NoPadding | jca/SymmetricModesTest.java:57:44:57:62 | jca/SymmetricModesTest.java:57:44:57:62 | +| jca/SymmetricModesTest.java:57:44:57:62 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricModesTest.java:57:44:57:62 | jca/SymmetricModesTest.java:57:44:57:62 | +| jca/SymmetricModesTest.java:57:44:57:62 | ModeOfOperation | RawName | KWP | jca/SymmetricModesTest.java:57:44:57:62 | jca/SymmetricModesTest.java:57:44:57:62 | +| jca/SymmetricModesTest.java:57:44:57:62 | PaddingAlgorithm | Name | UnknownPadding | jca/SymmetricModesTest.java:57:44:57:62 | jca/SymmetricModesTest.java:57:44:57:62 | +| jca/SymmetricModesTest.java:57:44:57:62 | PaddingAlgorithm | RawName | NoPadding | jca/SymmetricModesTest.java:57:44:57:62 | jca/SymmetricModesTest.java:57:44:57:62 | +| jca/SymmetricModesTest.java:58:39:58:49 | Key | KeyType | Unknown | jca/SymmetricModesTest.java:58:39:58:49 | jca/SymmetricModesTest.java:58:39:58:49 | +| jca/SymmetricModesTest.java:59:29:59:50 | WrapOperation | KeyOperationSubtype | Wrap | jca/SymmetricModesTest.java:59:29:59:50 | jca/SymmetricModesTest.java:59:29:59:50 | +| jca/SymmetricModesTest.java:78:43:78:55 | Parameter | Description | key | jca/SymmetricModesTest.java:78:43:78:55 | jca/SymmetricModesTest.java:78:43:78:55 | +| jca/SymmetricModesTest.java:78:58:78:73 | Parameter | Description | plaintext | jca/SymmetricModesTest.java:78:58:78:73 | jca/SymmetricModesTest.java:78:58:78:73 | +| jca/SymmetricModesTest.java:79:44:79:63 | KeyOperationAlgorithm | Name | AES | jca/SymmetricModesTest.java:79:44:79:63 | jca/SymmetricModesTest.java:79:44:79:63 | +| jca/SymmetricModesTest.java:79:44:79:63 | KeyOperationAlgorithm | RawName | AES/OFB8/NoPadding | jca/SymmetricModesTest.java:79:44:79:63 | jca/SymmetricModesTest.java:79:44:79:63 | +| jca/SymmetricModesTest.java:79:44:79:63 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricModesTest.java:79:44:79:63 | jca/SymmetricModesTest.java:79:44:79:63 | +| jca/SymmetricModesTest.java:79:44:79:63 | ModeOfOperation | RawName | OFB8 | jca/SymmetricModesTest.java:79:44:79:63 | jca/SymmetricModesTest.java:79:44:79:63 | +| jca/SymmetricModesTest.java:79:44:79:63 | PaddingAlgorithm | Name | UnknownPadding | jca/SymmetricModesTest.java:79:44:79:63 | jca/SymmetricModesTest.java:79:44:79:63 | +| jca/SymmetricModesTest.java:79:44:79:63 | PaddingAlgorithm | RawName | NoPadding | jca/SymmetricModesTest.java:79:44:79:63 | jca/SymmetricModesTest.java:79:44:79:63 | +| jca/SymmetricModesTest.java:81:9:81:40 | RandomNumberGeneration | Description | nextBytes | jca/SymmetricModesTest.java:81:9:81:40 | jca/SymmetricModesTest.java:81:9:81:40 | +| jca/SymmetricModesTest.java:81:38:81:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/SymmetricModesTest.java:81:38:81:39 | jca/SymmetricModesTest.java:81:38:81:39 | +| jca/SymmetricModesTest.java:83:42:83:44 | Key | KeyType | Unknown | jca/SymmetricModesTest.java:83:42:83:44 | jca/SymmetricModesTest.java:83:42:83:44 | +| jca/SymmetricModesTest.java:84:29:84:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricModesTest.java:84:29:84:53 | jca/SymmetricModesTest.java:84:29:84:53 | +| jca/SymmetricModesTest.java:104:45:104:57 | Parameter | Description | key | jca/SymmetricModesTest.java:104:45:104:57 | jca/SymmetricModesTest.java:104:45:104:57 | +| jca/SymmetricModesTest.java:104:60:104:75 | Parameter | Description | plaintext | jca/SymmetricModesTest.java:104:60:104:75 | jca/SymmetricModesTest.java:104:60:104:75 | +| jca/SymmetricModesTest.java:105:44:105:63 | KeyOperationAlgorithm | Name | AES | jca/SymmetricModesTest.java:105:44:105:63 | jca/SymmetricModesTest.java:105:44:105:63 | +| jca/SymmetricModesTest.java:105:44:105:63 | KeyOperationAlgorithm | RawName | AES/OFB8/NoPadding | jca/SymmetricModesTest.java:105:44:105:63 | jca/SymmetricModesTest.java:105:44:105:63 | +| jca/SymmetricModesTest.java:105:44:105:63 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricModesTest.java:105:44:105:63 | jca/SymmetricModesTest.java:105:44:105:63 | +| jca/SymmetricModesTest.java:105:44:105:63 | ModeOfOperation | RawName | OFB8 | jca/SymmetricModesTest.java:105:44:105:63 | jca/SymmetricModesTest.java:105:44:105:63 | +| jca/SymmetricModesTest.java:105:44:105:63 | PaddingAlgorithm | Name | UnknownPadding | jca/SymmetricModesTest.java:105:44:105:63 | jca/SymmetricModesTest.java:105:44:105:63 | +| jca/SymmetricModesTest.java:105:44:105:63 | PaddingAlgorithm | RawName | NoPadding | jca/SymmetricModesTest.java:105:44:105:63 | jca/SymmetricModesTest.java:105:44:105:63 | +| jca/SymmetricModesTest.java:109:42:109:44 | Key | KeyType | Unknown | jca/SymmetricModesTest.java:109:42:109:44 | jca/SymmetricModesTest.java:109:42:109:44 | +| jca/SymmetricModesTest.java:110:29:110:53 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/SymmetricModesTest.java:110:29:110:53 | jca/SymmetricModesTest.java:110:29:110:53 | +| jca/SymmetricModesTest.java:127:52:127:56 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/SymmetricModesTest.java:128:17:128:19 | jca/SymmetricModesTest.java:128:17:128:19 | +| jca/SymmetricModesTest.java:127:52:127:56 | KeyOperationAlgorithm | Name | AES | jca/SymmetricModesTest.java:127:52:127:56 | jca/SymmetricModesTest.java:127:52:127:56 | +| jca/SymmetricModesTest.java:127:52:127:56 | KeyOperationAlgorithm | RawName | AES | jca/SymmetricModesTest.java:127:52:127:56 | jca/SymmetricModesTest.java:127:52:127:56 | +| jca/SymmetricModesTest.java:127:52:127:56 | KeyOperationAlgorithm | Structure | Block | jca/SymmetricModesTest.java:127:52:127:56 | jca/SymmetricModesTest.java:127:52:127:56 | +| jca/SymmetricModesTest.java:128:17:128:19 | Constant | Description | 256 | jca/SymmetricModesTest.java:128:17:128:19 | jca/SymmetricModesTest.java:128:17:128:19 | +| jca/SymmetricModesTest.java:129:16:129:31 | Key | KeyType | Symmetric | jca/SymmetricModesTest.java:129:16:129:31 | jca/SymmetricModesTest.java:129:16:129:31 | +| jca/UniversalFlowTest.java:19:28:19:32 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/UniversalFlowTest.java:26:21:26:23 | jca/UniversalFlowTest.java:26:21:26:23 | +| jca/UniversalFlowTest.java:19:28:19:32 | KeyOperationAlgorithm | Name | AES | jca/UniversalFlowTest.java:19:28:19:32 | jca/UniversalFlowTest.java:19:28:19:32 | +| jca/UniversalFlowTest.java:19:28:19:32 | KeyOperationAlgorithm | RawName | AES | jca/UniversalFlowTest.java:19:28:19:32 | jca/UniversalFlowTest.java:19:28:19:32 | +| jca/UniversalFlowTest.java:19:28:19:32 | KeyOperationAlgorithm | Structure | Block | jca/UniversalFlowTest.java:19:28:19:32 | jca/UniversalFlowTest.java:19:28:19:32 | +| jca/UniversalFlowTest.java:26:21:26:23 | Constant | Description | 256 | jca/UniversalFlowTest.java:26:21:26:23 | jca/UniversalFlowTest.java:26:21:26:23 | +| jca/UniversalFlowTest.java:27:25:27:44 | Key | KeyType | Symmetric | jca/UniversalFlowTest.java:27:25:27:44 | jca/UniversalFlowTest.java:27:25:27:44 | +| jca/UniversalFlowTest.java:28:29:28:47 | KeyOperationAlgorithm | Name | AES | jca/UniversalFlowTest.java:28:29:28:47 | jca/UniversalFlowTest.java:28:29:28:47 | +| jca/UniversalFlowTest.java:28:29:28:47 | KeyOperationAlgorithm | RawName | AES/GCM/NoPadding | jca/UniversalFlowTest.java:28:29:28:47 | jca/UniversalFlowTest.java:28:29:28:47 | +| jca/UniversalFlowTest.java:28:29:28:47 | KeyOperationAlgorithm | Structure | Block | jca/UniversalFlowTest.java:28:29:28:47 | jca/UniversalFlowTest.java:28:29:28:47 | +| jca/UniversalFlowTest.java:28:29:28:47 | ModeOfOperation | Name | GCM | jca/UniversalFlowTest.java:28:29:28:47 | jca/UniversalFlowTest.java:28:29:28:47 | +| jca/UniversalFlowTest.java:28:29:28:47 | ModeOfOperation | RawName | GCM | jca/UniversalFlowTest.java:28:29:28:47 | jca/UniversalFlowTest.java:28:29:28:47 | +| jca/UniversalFlowTest.java:28:29:28:47 | PaddingAlgorithm | Name | UnknownPadding | jca/UniversalFlowTest.java:28:29:28:47 | jca/UniversalFlowTest.java:28:29:28:47 | +| jca/UniversalFlowTest.java:28:29:28:47 | PaddingAlgorithm | RawName | NoPadding | jca/UniversalFlowTest.java:28:29:28:47 | jca/UniversalFlowTest.java:28:29:28:47 | +| jca/UniversalFlowTest.java:31:9:31:40 | RandomNumberGeneration | Description | nextBytes | jca/UniversalFlowTest.java:31:9:31:40 | jca/UniversalFlowTest.java:31:9:31:40 | +| jca/UniversalFlowTest.java:31:38:31:39 | RandomNumberGeneration | Description | java.security.SecureRandom | jca/UniversalFlowTest.java:31:38:31:39 | jca/UniversalFlowTest.java:31:38:31:39 | +| jca/UniversalFlowTest.java:33:42:33:44 | Key | KeyType | Unknown | jca/UniversalFlowTest.java:33:42:33:44 | jca/UniversalFlowTest.java:33:42:33:44 | +| jca/UniversalFlowTest.java:34:32:34:74 | EncryptOperation | KeyOperationSubtype | Encrypt | jca/UniversalFlowTest.java:34:32:34:74 | jca/UniversalFlowTest.java:34:32:34:74 | +| jca/UniversalFlowTest.java:34:47:34:62 | Constant | Description | "Sensitive Data" | jca/UniversalFlowTest.java:34:47:34:62 | jca/UniversalFlowTest.java:34:47:34:62 | +| jca/UniversalFlowTest.java:46:20:46:24 | KeyOperationAlgorithm | KeySize | Constant:256 | jca/UniversalFlowTest.java:26:21:26:23 | jca/UniversalFlowTest.java:26:21:26:23 | +| jca/UniversalFlowTest.java:46:20:46:24 | KeyOperationAlgorithm | Name | AES | jca/UniversalFlowTest.java:46:20:46:24 | jca/UniversalFlowTest.java:46:20:46:24 | +| jca/UniversalFlowTest.java:46:20:46:24 | KeyOperationAlgorithm | RawName | AES | jca/UniversalFlowTest.java:46:20:46:24 | jca/UniversalFlowTest.java:46:20:46:24 | +| jca/UniversalFlowTest.java:46:20:46:24 | KeyOperationAlgorithm | Structure | Block | jca/UniversalFlowTest.java:46:20:46:24 | jca/UniversalFlowTest.java:46:20:46:24 | diff --git a/java/ql/test/experimental/library-tests/quantum/node_properties.ql b/java/ql/test/experimental/library-tests/quantum/node_properties.ql new file mode 100644 index 000000000000..79514611e679 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/node_properties.ql @@ -0,0 +1,6 @@ +import java +import experimental.quantum.Language + +from Crypto::NodeBase n, string key, string value, Location location +where n.properties(key, value, location) +select n, key, value, location diff --git a/java/ql/test/experimental/library-tests/quantum/nodes.expected b/java/ql/test/experimental/library-tests/quantum/nodes.expected new file mode 100644 index 000000000000..39816c682343 --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/nodes.expected @@ -0,0 +1,1515 @@ +| jca/AesWrapAndPBEWith.java:58:52:58:56 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:59:17:59:19 | Constant | +| jca/AesWrapAndPBEWith.java:60:33:60:48 | Key | +| jca/AesWrapAndPBEWith.java:60:33:60:48 | KeyGeneration | +| jca/AesWrapAndPBEWith.java:62:17:62:19 | Constant | +| jca/AesWrapAndPBEWith.java:63:31:63:46 | Key | +| jca/AesWrapAndPBEWith.java:63:31:63:46 | KeyGeneration | +| jca/AesWrapAndPBEWith.java:65:44:65:52 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:66:39:66:49 | Key | +| jca/AesWrapAndPBEWith.java:67:29:67:50 | KeyOperationOutput | +| jca/AesWrapAndPBEWith.java:67:29:67:50 | WrapOperation | +| jca/AesWrapAndPBEWith.java:67:41:67:49 | Message | +| jca/AesWrapAndPBEWith.java:83:52:83:56 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:84:17:84:19 | Constant | +| jca/AesWrapAndPBEWith.java:85:31:85:46 | Key | +| jca/AesWrapAndPBEWith.java:85:31:85:46 | KeyGeneration | +| jca/AesWrapAndPBEWith.java:87:44:87:52 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:88:39:88:49 | Key | +| jca/AesWrapAndPBEWith.java:89:29:89:50 | KeyOperationOutput | +| jca/AesWrapAndPBEWith.java:89:29:89:50 | WrapOperation | +| jca/AesWrapAndPBEWith.java:89:41:89:49 | Message | +| jca/AesWrapAndPBEWith.java:106:34:106:37 | Constant | +| jca/AesWrapAndPBEWith.java:107:42:107:63 | Message | +| jca/AesWrapAndPBEWith.java:107:66:107:69 | Salt | +| jca/AesWrapAndPBEWith.java:107:72:107:75 | Constant | +| jca/AesWrapAndPBEWith.java:107:78:107:79 | Constant | +| jca/AesWrapAndPBEWith.java:108:65:108:82 | KeyDerivationAlgorithm | +| jca/AesWrapAndPBEWith.java:109:27:109:54 | Key | +| jca/AesWrapAndPBEWith.java:109:27:109:54 | KeyDerivation | +| jca/AesWrapAndPBEWith.java:122:9:122:42 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:122:38:122:41 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:123:42:123:63 | Message | +| jca/AesWrapAndPBEWith.java:123:66:123:69 | Salt | +| jca/AesWrapAndPBEWith.java:123:72:123:76 | Constant | +| jca/AesWrapAndPBEWith.java:123:79:123:81 | Constant | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | HMACAlgorithm | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | HashAlgorithm | +| jca/AesWrapAndPBEWith.java:124:65:124:86 | KeyDerivationAlgorithm | +| jca/AesWrapAndPBEWith.java:125:27:125:54 | Key | +| jca/AesWrapAndPBEWith.java:125:27:125:54 | KeyDerivation | +| jca/AesWrapAndPBEWith.java:140:9:140:42 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:140:38:140:41 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:141:42:141:63 | Message | +| jca/AesWrapAndPBEWith.java:141:66:141:69 | Salt | +| jca/AesWrapAndPBEWith.java:141:72:141:76 | Constant | +| jca/AesWrapAndPBEWith.java:141:79:141:81 | Constant | +| jca/AesWrapAndPBEWith.java:142:65:142:98 | KeyDerivationAlgorithm | +| jca/AesWrapAndPBEWith.java:143:28:143:55 | Key | +| jca/AesWrapAndPBEWith.java:143:28:143:55 | KeyDerivation | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | ModeOfOperation | +| jca/AesWrapAndPBEWith.java:146:44:146:65 | PaddingAlgorithm | +| jca/AesWrapAndPBEWith.java:148:9:148:40 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:148:38:148:39 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:150:42:150:47 | Key | +| jca/AesWrapAndPBEWith.java:150:50:150:55 | Nonce | +| jca/AesWrapAndPBEWith.java:151:29:151:64 | EncryptOperation | +| jca/AesWrapAndPBEWith.java:151:29:151:64 | KeyOperationOutput | +| jca/AesWrapAndPBEWith.java:151:44:151:63 | Message | +| jca/AesWrapAndPBEWith.java:167:9:167:42 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:167:38:167:41 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:168:42:168:63 | Message | +| jca/AesWrapAndPBEWith.java:168:66:168:69 | Salt | +| jca/AesWrapAndPBEWith.java:168:72:168:76 | Constant | +| jca/AesWrapAndPBEWith.java:168:79:168:81 | Constant | +| jca/AesWrapAndPBEWith.java:169:65:169:96 | KeyDerivationAlgorithm | +| jca/AesWrapAndPBEWith.java:170:28:170:55 | Key | +| jca/AesWrapAndPBEWith.java:170:28:170:55 | KeyDerivation | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | KeyOperationAlgorithm | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | ModeOfOperation | +| jca/AesWrapAndPBEWith.java:173:44:173:65 | PaddingAlgorithm | +| jca/AesWrapAndPBEWith.java:175:9:175:40 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:175:38:175:39 | RandomNumberGeneration | +| jca/AesWrapAndPBEWith.java:177:42:177:47 | Key | +| jca/AesWrapAndPBEWith.java:177:50:177:55 | Nonce | +| jca/AesWrapAndPBEWith.java:178:29:178:64 | EncryptOperation | +| jca/AesWrapAndPBEWith.java:178:29:178:64 | KeyOperationOutput | +| jca/AesWrapAndPBEWith.java:178:44:178:63 | Message | +| jca/AesWrapAndPBEWith.java:200:55:200:69 | Parameter | +| jca/AesWrapAndPBEWith.java:200:72:200:87 | Parameter | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:86:47:86:57 | EllipticCurve | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:87:16:87:36 | KeyGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:94:61:94:68 | KeyAgreementAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:95:24:95:26 | Constant | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:96:16:96:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:96:16:96:36 | KeyGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:109:17:109:26 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:110:20:110:28 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | KeyAgreementOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:111:16:111:34 | SharedSecret | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:123:58:123:66 | HashAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:23:124:42 | Digest | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:23:124:42 | HashOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:124:37:124:41 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:145:61:145:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:146:24:146:27 | Constant | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:147:16:147:36 | KeyGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:154:61:154:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:155:24:155:27 | Constant | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:156:16:156:36 | KeyGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | HashAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:166:47:166:85 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:167:42:167:58 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:34:168:55 | WrapOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:168:49:168:54 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:9:171:40 | RandomNumberGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:171:38:171:39 | RandomNumberGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:172:47:172:65 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:45:173:50 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:173:53:173:81 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | EncryptOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:29:174:56 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:174:47:174:55 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:190:47:190:68 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:191:42:191:58 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:34:192:55 | WrapOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:192:49:192:54 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:195:47:195:65 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:45:196:50 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:196:53:196:86 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | EncryptOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:29:197:56 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:197:47:197:55 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:215:91:215:96 | KeyAgreementAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:9:220:40 | RandomNumberGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:220:38:220:39 | RandomNumberGeneration | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:221:44:221:62 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:42:222:47 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:222:50:222:78 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | EncryptOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:29:223:53 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:223:44:223:52 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:239:95:239:100 | KeyAgreementAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | ModeOfOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:244:44:244:62 | PaddingAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:42:245:47 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:245:50:245:83 | Nonce | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | EncryptOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:29:246:53 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:246:44:246:52 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:271:58:271:73 | Parameter | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:295:35:295:46 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:297:18:297:26 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:16:298:46 | MACOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:298:28:298:45 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:306:35:306:44 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:308:18:308:26 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | KeyOperationOutput | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:16:309:46 | MACOperation | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:309:28:309:45 | Message | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:320:52:320:56 | KeyOperationAlgorithm | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:321:17:321:19 | Constant | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | Key | +| jca/AsymmetricEncryptionMacHybridCryptosystem.java:322:16:322:31 | KeyGeneration | +| jca/ChainedEncryptionTest.java:19:44:19:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:19:44:19:62 | ModeOfOperation | +| jca/ChainedEncryptionTest.java:19:44:19:62 | PaddingAlgorithm | +| jca/ChainedEncryptionTest.java:21:9:21:40 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:21:38:21:39 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:23:42:23:44 | Key | +| jca/ChainedEncryptionTest.java:23:47:23:50 | Nonce | +| jca/ChainedEncryptionTest.java:24:29:24:53 | EncryptOperation | +| jca/ChainedEncryptionTest.java:24:29:24:53 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:24:44:24:52 | Message | +| jca/ChainedEncryptionTest.java:32:44:32:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:32:44:32:62 | ModeOfOperation | +| jca/ChainedEncryptionTest.java:32:44:32:62 | PaddingAlgorithm | +| jca/ChainedEncryptionTest.java:34:42:34:44 | Key | +| jca/ChainedEncryptionTest.java:34:47:34:50 | Nonce | +| jca/ChainedEncryptionTest.java:35:16:35:41 | DecryptOperation | +| jca/ChainedEncryptionTest.java:35:16:35:41 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:35:31:35:40 | Message | +| jca/ChainedEncryptionTest.java:40:44:40:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:42:9:42:43 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:42:38:42:42 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:43:42:43:44 | Key | +| jca/ChainedEncryptionTest.java:43:47:43:72 | Nonce | +| jca/ChainedEncryptionTest.java:44:29:44:53 | EncryptOperation | +| jca/ChainedEncryptionTest.java:44:29:44:53 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:44:44:44:52 | Message | +| jca/ChainedEncryptionTest.java:52:44:52:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:53:42:53:44 | Key | +| jca/ChainedEncryptionTest.java:53:47:53:72 | Nonce | +| jca/ChainedEncryptionTest.java:54:16:54:41 | DecryptOperation | +| jca/ChainedEncryptionTest.java:54:16:54:41 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:54:31:54:40 | Message | +| jca/ChainedEncryptionTest.java:75:46:75:61 | Parameter | +| jca/ChainedEncryptionTest.java:79:56:79:60 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:80:21:80:23 | Constant | +| jca/ChainedEncryptionTest.java:81:30:81:49 | Key | +| jca/ChainedEncryptionTest.java:81:30:81:49 | KeyGeneration | +| jca/ChainedEncryptionTest.java:83:59:83:68 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:84:24:84:26 | Constant | +| jca/ChainedEncryptionTest.java:85:30:85:52 | Key | +| jca/ChainedEncryptionTest.java:85:30:85:52 | KeyGeneration | +| jca/ChainedEncryptionTest.java:89:9:89:43 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:89:38:89:42 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:90:47:90:65 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:90:47:90:65 | ModeOfOperation | +| jca/ChainedEncryptionTest.java:90:47:90:65 | PaddingAlgorithm | +| jca/ChainedEncryptionTest.java:92:45:92:52 | Key | +| jca/ChainedEncryptionTest.java:92:55:92:61 | Nonce | +| jca/ChainedEncryptionTest.java:93:34:93:62 | EncryptOperation | +| jca/ChainedEncryptionTest.java:93:34:93:62 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:93:52:93:61 | Message | +| jca/ChainedEncryptionTest.java:97:9:97:49 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:97:38:97:48 | RandomNumberGeneration | +| jca/ChainedEncryptionTest.java:98:50:98:68 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:99:48:99:55 | Key | +| jca/ChainedEncryptionTest.java:99:58:99:89 | Nonce | +| jca/ChainedEncryptionTest.java:100:34:100:70 | EncryptOperation | +| jca/ChainedEncryptionTest.java:100:34:100:70 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:100:55:100:69 | Message | +| jca/ChainedEncryptionTest.java:103:47:103:65 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:104:45:104:52 | Key | +| jca/ChainedEncryptionTest.java:104:55:104:86 | Nonce | +| jca/ChainedEncryptionTest.java:105:43:105:76 | DecryptOperation | +| jca/ChainedEncryptionTest.java:105:43:105:76 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:105:61:105:75 | Message | +| jca/ChainedEncryptionTest.java:108:44:108:62 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:108:44:108:62 | ModeOfOperation | +| jca/ChainedEncryptionTest.java:108:44:108:62 | PaddingAlgorithm | +| jca/ChainedEncryptionTest.java:109:42:109:49 | Key | +| jca/ChainedEncryptionTest.java:109:52:109:83 | Nonce | +| jca/ChainedEncryptionTest.java:110:37:110:76 | DecryptOperation | +| jca/ChainedEncryptionTest.java:110:37:110:76 | KeyOperationOutput | +| jca/ChainedEncryptionTest.java:110:52:110:75 | Message | +| jca/ChainedEncryptionTest.java:117:56:117:60 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:118:21:118:23 | Constant | +| jca/ChainedEncryptionTest.java:119:28:119:47 | Key | +| jca/ChainedEncryptionTest.java:119:28:119:47 | KeyGeneration | +| jca/ChainedEncryptionTest.java:122:59:122:68 | KeyOperationAlgorithm | +| jca/ChainedEncryptionTest.java:123:24:123:26 | Constant | +| jca/ChainedEncryptionTest.java:124:31:124:53 | Key | +| jca/ChainedEncryptionTest.java:124:31:124:53 | KeyGeneration | +| jca/ChainedEncryptionTest.java:126:31:126:57 | Constant | +| jca/Digest.java:54:58:54:66 | HashAlgorithm | +| jca/Digest.java:55:23:55:66 | Digest | +| jca/Digest.java:55:23:55:66 | HashOperation | +| jca/Digest.java:55:37:55:54 | Constant | +| jca/Digest.java:55:37:55:65 | Message | +| jca/Digest.java:64:61:64:65 | HashAlgorithm | +| jca/Digest.java:65:23:65:70 | Digest | +| jca/Digest.java:65:23:65:70 | HashOperation | +| jca/Digest.java:65:40:65:58 | Constant | +| jca/Digest.java:65:40:65:69 | Message | +| jca/Digest.java:73:49:73:63 | Parameter | +| jca/Digest.java:74:64:74:72 | HashAlgorithm | +| jca/Digest.java:75:23:75:62 | Digest | +| jca/Digest.java:75:23:75:62 | HashOperation | +| jca/Digest.java:75:43:75:61 | Message | +| jca/Digest.java:83:37:83:51 | Parameter | +| jca/Digest.java:85:58:85:66 | HashAlgorithm | +| jca/Digest.java:86:23:86:26 | Message | +| jca/Digest.java:87:23:87:56 | Digest | +| jca/Digest.java:87:23:87:56 | HashOperation | +| jca/Digest.java:87:37:87:55 | Message | +| jca/Digest.java:95:37:95:51 | Parameter | +| jca/Digest.java:97:42:97:63 | Message | +| jca/Digest.java:97:66:97:69 | Salt | +| jca/Digest.java:97:72:97:76 | Constant | +| jca/Digest.java:97:79:97:81 | Constant | +| jca/Digest.java:98:65:98:86 | HMACAlgorithm | +| jca/Digest.java:98:65:98:86 | HashAlgorithm | +| jca/Digest.java:98:65:98:86 | KeyDerivationAlgorithm | +| jca/Digest.java:99:23:99:50 | Key | +| jca/Digest.java:99:23:99:50 | KeyDerivation | +| jca/Digest.java:107:40:107:51 | Parameter | +| jca/Digest.java:108:62:108:68 | HashAlgorithm | +| jca/Digest.java:109:23:109:57 | Digest | +| jca/Digest.java:109:23:109:57 | HashOperation | +| jca/Digest.java:109:41:109:56 | Message | +| jca/Digest.java:117:35:117:46 | Parameter | +| jca/Digest.java:117:49:117:58 | Parameter | +| jca/Digest.java:118:36:118:47 | KeyOperationAlgorithm | +| jca/Digest.java:120:19:120:27 | Key | +| jca/Digest.java:121:23:121:52 | KeyOperationOutput | +| jca/Digest.java:121:23:121:52 | MACOperation | +| jca/Digest.java:121:36:121:51 | Message | +| jca/Digest.java:140:44:140:62 | KeyOperationAlgorithm | +| jca/Digest.java:140:44:140:62 | ModeOfOperation | +| jca/Digest.java:140:44:140:62 | PaddingAlgorithm | +| jca/Digest.java:141:42:141:44 | Key | +| jca/Digest.java:142:32:142:74 | EncryptOperation | +| jca/Digest.java:142:32:142:74 | KeyOperationOutput | +| jca/Digest.java:142:47:142:62 | Constant | +| jca/Digest.java:142:47:142:73 | Message | +| jca/Digest.java:155:39:155:51 | Parameter | +| jca/Digest.java:171:50:171:62 | Parameter | +| jca/Digest.java:176:42:176:71 | Message | +| jca/Digest.java:176:74:176:77 | Salt | +| jca/Digest.java:176:80:176:84 | Constant | +| jca/Digest.java:176:87:176:89 | Constant | +| jca/Digest.java:177:65:177:86 | HMACAlgorithm | +| jca/Digest.java:177:65:177:86 | HashAlgorithm | +| jca/Digest.java:177:65:177:86 | KeyDerivationAlgorithm | +| jca/Digest.java:178:30:178:57 | Key | +| jca/Digest.java:178:30:178:57 | KeyDerivation | +| jca/Digest.java:186:44:186:62 | KeyOperationAlgorithm | +| jca/Digest.java:186:44:186:62 | ModeOfOperation | +| jca/Digest.java:186:44:186:62 | PaddingAlgorithm | +| jca/Digest.java:187:42:187:54 | Key | +| jca/Digest.java:188:29:188:78 | EncryptOperation | +| jca/Digest.java:188:29:188:78 | KeyOperationOutput | +| jca/Digest.java:188:44:188:66 | Constant | +| jca/Digest.java:188:44:188:77 | Message | +| jca/Digest.java:191:35:191:46 | KeyOperationAlgorithm | +| jca/Digest.java:192:18:192:23 | Key | +| jca/Digest.java:193:30:193:52 | KeyOperationOutput | +| jca/Digest.java:193:30:193:52 | MACOperation | +| jca/Digest.java:193:42:193:51 | Message | +| jca/Digest.java:210:44:210:62 | KeyOperationAlgorithm | +| jca/Digest.java:210:44:210:62 | ModeOfOperation | +| jca/Digest.java:210:44:210:62 | PaddingAlgorithm | +| jca/Digest.java:212:42:212:44 | Key | +| jca/Digest.java:213:32:213:51 | EncryptOperation | +| jca/Digest.java:213:32:213:51 | KeyOperationOutput | +| jca/Digest.java:213:47:213:50 | Message | +| jca/Digest.java:239:56:239:60 | KeyOperationAlgorithm | +| jca/Digest.java:240:21:240:23 | Constant | +| jca/Digest.java:241:16:241:35 | Key | +| jca/Digest.java:241:16:241:35 | KeyGeneration | +| jca/Digest.java:253:9:253:42 | RandomNumberGeneration | +| jca/Digest.java:253:38:253:41 | RandomNumberGeneration | +| jca/EllipticCurve1.java:46:66:46:76 | EllipticCurve | +| jca/EllipticCurve1.java:47:16:47:36 | Key | +| jca/EllipticCurve1.java:47:16:47:36 | KeyGeneration | +| jca/EllipticCurve1.java:56:66:56:76 | EllipticCurve | +| jca/EllipticCurve1.java:57:16:57:36 | Key | +| jca/EllipticCurve1.java:57:16:57:36 | KeyGeneration | +| jca/EllipticCurve1.java:66:66:66:82 | EllipticCurve | +| jca/EllipticCurve1.java:67:16:67:36 | Key | +| jca/EllipticCurve1.java:67:16:67:36 | KeyGeneration | +| jca/EllipticCurve1.java:74:61:74:68 | KeyAgreementAlgorithm | +| jca/EllipticCurve1.java:76:16:76:36 | Key | +| jca/EllipticCurve1.java:76:16:76:36 | KeyGeneration | +| jca/EllipticCurve1.java:83:61:83:66 | KeyAgreementAlgorithm | +| jca/EllipticCurve1.java:84:16:84:36 | Key | +| jca/EllipticCurve1.java:84:16:84:36 | KeyGeneration | +| jca/EllipticCurve1.java:94:66:94:76 | EllipticCurve | +| jca/EllipticCurve1.java:95:16:95:36 | Key | +| jca/EllipticCurve1.java:95:16:95:36 | KeyGeneration | +| jca/EllipticCurve1.java:105:66:105:76 | Constant | +| jca/EllipticCurve1.java:106:16:106:36 | Key | +| jca/EllipticCurve1.java:106:16:106:36 | KeyGeneration | +| jca/EllipticCurve1.java:114:61:114:69 | Constant | +| jca/EllipticCurve1.java:115:16:115:36 | Key | +| jca/EllipticCurve1.java:115:16:115:36 | KeyGeneration | +| jca/EllipticCurve2.java:46:47:46:57 | EllipticCurve | +| jca/EllipticCurve2.java:47:16:47:36 | Key | +| jca/EllipticCurve2.java:47:16:47:36 | KeyGeneration | +| jca/EllipticCurve2.java:55:47:55:57 | EllipticCurve | +| jca/EllipticCurve2.java:56:16:56:36 | Key | +| jca/EllipticCurve2.java:56:16:56:36 | KeyGeneration | +| jca/EllipticCurve2.java:64:47:64:63 | EllipticCurve | +| jca/EllipticCurve2.java:65:16:65:36 | Key | +| jca/EllipticCurve2.java:65:16:65:36 | KeyGeneration | +| jca/EllipticCurve2.java:72:61:72:68 | KeyAgreementAlgorithm | +| jca/EllipticCurve2.java:73:16:73:36 | Key | +| jca/EllipticCurve2.java:73:16:73:36 | KeyGeneration | +| jca/EllipticCurve2.java:80:61:80:69 | Constant | +| jca/EllipticCurve2.java:81:16:81:36 | Key | +| jca/EllipticCurve2.java:81:16:81:36 | KeyGeneration | +| jca/EllipticCurve2.java:105:52:105:57 | KeyAgreementAlgorithm | +| jca/EllipticCurve2.java:106:17:106:36 | Key | +| jca/EllipticCurve2.java:107:20:107:36 | Key | +| jca/EllipticCurve2.java:108:16:108:34 | KeyAgreementOperation | +| jca/EllipticCurve2.java:108:16:108:34 | SharedSecret | +| jca/EllipticCurve2.java:119:52:119:57 | KeyAgreementAlgorithm | +| jca/EllipticCurve2.java:120:17:120:37 | Key | +| jca/EllipticCurve2.java:121:20:121:39 | Key | +| jca/EllipticCurve2.java:122:16:122:34 | KeyAgreementOperation | +| jca/EllipticCurve2.java:122:16:122:34 | SharedSecret | +| jca/EllipticCurve2.java:136:53:136:69 | HashAlgorithm | +| jca/EllipticCurve2.java:136:53:136:69 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:137:28:137:42 | Key | +| jca/EllipticCurve2.java:138:26:138:32 | Message | +| jca/EllipticCurve2.java:139:16:139:31 | SignOperation | +| jca/EllipticCurve2.java:139:16:139:31 | SignatureOutput | +| jca/EllipticCurve2.java:151:53:151:69 | HashAlgorithm | +| jca/EllipticCurve2.java:151:53:151:69 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:152:30:152:43 | Key | +| jca/EllipticCurve2.java:153:26:153:32 | Message | +| jca/EllipticCurve2.java:154:16:154:47 | VerifyOperation | +| jca/EllipticCurve2.java:154:33:154:46 | SignatureInput | +| jca/EllipticCurve2.java:166:53:166:61 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:167:28:167:42 | Key | +| jca/EllipticCurve2.java:168:26:168:32 | Message | +| jca/EllipticCurve2.java:169:16:169:31 | SignOperation | +| jca/EllipticCurve2.java:169:16:169:31 | SignatureOutput | +| jca/EllipticCurve2.java:181:53:181:61 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:182:30:182:43 | Key | +| jca/EllipticCurve2.java:183:26:183:32 | Message | +| jca/EllipticCurve2.java:184:16:184:47 | VerifyOperation | +| jca/EllipticCurve2.java:184:33:184:46 | SignatureInput | +| jca/EllipticCurve2.java:206:52:206:57 | KeyAgreementAlgorithm | +| jca/EllipticCurve2.java:207:17:207:37 | Key | +| jca/EllipticCurve2.java:208:20:208:41 | Key | +| jca/EllipticCurve2.java:209:31:209:49 | KeyAgreementOperation | +| jca/EllipticCurve2.java:209:31:209:49 | SharedSecret | +| jca/EllipticCurve2.java:213:58:213:66 | HashAlgorithm | +| jca/EllipticCurve2.java:214:29:214:55 | Digest | +| jca/EllipticCurve2.java:214:29:214:55 | HashOperation | +| jca/EllipticCurve2.java:214:43:214:54 | Message | +| jca/EllipticCurve2.java:219:44:219:62 | KeyOperationAlgorithm | +| jca/EllipticCurve2.java:219:44:219:62 | ModeOfOperation | +| jca/EllipticCurve2.java:219:44:219:62 | PaddingAlgorithm | +| jca/EllipticCurve2.java:221:9:221:40 | RandomNumberGeneration | +| jca/EllipticCurve2.java:221:38:221:39 | RandomNumberGeneration | +| jca/EllipticCurve2.java:223:42:223:47 | Key | +| jca/EllipticCurve2.java:223:50:223:53 | Nonce | +| jca/EllipticCurve2.java:224:29:224:53 | EncryptOperation | +| jca/EllipticCurve2.java:224:29:224:53 | KeyOperationOutput | +| jca/EllipticCurve2.java:224:44:224:52 | Message | +| jca/EllipticCurve2.java:245:30:245:53 | Constant | +| jca/EllipticCurve2.java:258:62:258:83 | Constant | +| jca/Encryption1.java:60:56:60:60 | KeyOperationAlgorithm | +| jca/Encryption1.java:61:21:61:23 | Constant | +| jca/Encryption1.java:62:25:62:44 | Key | +| jca/Encryption1.java:62:25:62:44 | KeyGeneration | +| jca/Encryption1.java:63:44:63:62 | KeyOperationAlgorithm | +| jca/Encryption1.java:63:44:63:62 | ModeOfOperation | +| jca/Encryption1.java:63:44:63:62 | PaddingAlgorithm | +| jca/Encryption1.java:65:9:65:40 | RandomNumberGeneration | +| jca/Encryption1.java:65:38:65:39 | RandomNumberGeneration | +| jca/Encryption1.java:67:42:67:44 | Key | +| jca/Encryption1.java:67:47:67:53 | Nonce | +| jca/Encryption1.java:68:32:68:74 | EncryptOperation | +| jca/Encryption1.java:68:32:68:74 | KeyOperationOutput | +| jca/Encryption1.java:68:47:68:62 | Constant | +| jca/Encryption1.java:68:47:68:73 | Message | +| jca/Encryption1.java:83:56:83:60 | KeyOperationAlgorithm | +| jca/Encryption1.java:84:21:84:23 | Constant | +| jca/Encryption1.java:85:25:85:44 | Key | +| jca/Encryption1.java:85:25:85:44 | KeyGeneration | +| jca/Encryption1.java:88:44:88:62 | KeyOperationAlgorithm | +| jca/Encryption1.java:88:44:88:62 | ModeOfOperation | +| jca/Encryption1.java:88:44:88:62 | PaddingAlgorithm | +| jca/Encryption1.java:89:42:89:44 | Key | +| jca/Encryption1.java:90:32:90:74 | EncryptOperation | +| jca/Encryption1.java:90:32:90:74 | KeyOperationOutput | +| jca/Encryption1.java:90:47:90:62 | Constant | +| jca/Encryption1.java:90:47:90:73 | Message | +| jca/Encryption1.java:104:35:104:53 | Parameter | +| jca/Encryption1.java:104:56:104:66 | Parameter | +| jca/Encryption1.java:105:44:105:82 | HashAlgorithm | +| jca/Encryption1.java:105:44:105:82 | KeyOperationAlgorithm | +| jca/Encryption1.java:105:44:105:82 | ModeOfOperation | +| jca/Encryption1.java:105:44:105:82 | PaddingAlgorithm | +| jca/Encryption1.java:106:42:106:50 | Key | +| jca/Encryption1.java:107:32:107:62 | EncryptOperation | +| jca/Encryption1.java:107:32:107:62 | KeyOperationOutput | +| jca/Encryption1.java:107:47:107:61 | Message | +| jca/Encryption1.java:119:35:119:55 | Parameter | +| jca/Encryption1.java:119:58:119:77 | Parameter | +| jca/Encryption1.java:120:44:120:82 | HashAlgorithm | +| jca/Encryption1.java:120:44:120:82 | KeyOperationAlgorithm | +| jca/Encryption1.java:120:44:120:82 | ModeOfOperation | +| jca/Encryption1.java:120:44:120:82 | PaddingAlgorithm | +| jca/Encryption1.java:121:42:121:51 | Key | +| jca/Encryption1.java:122:32:122:60 | DecryptOperation | +| jca/Encryption1.java:122:32:122:60 | KeyOperationOutput | +| jca/Encryption1.java:122:47:122:59 | Message | +| jca/Encryption1.java:136:34:136:55 | Parameter | +| jca/Encryption1.java:137:56:137:60 | KeyOperationAlgorithm | +| jca/Encryption1.java:138:21:138:23 | Constant | +| jca/Encryption1.java:139:28:139:47 | Key | +| jca/Encryption1.java:139:28:139:47 | KeyGeneration | +| jca/Encryption1.java:141:47:141:85 | HashAlgorithm | +| jca/Encryption1.java:141:47:141:85 | KeyOperationAlgorithm | +| jca/Encryption1.java:141:47:141:85 | ModeOfOperation | +| jca/Encryption1.java:141:47:141:85 | PaddingAlgorithm | +| jca/Encryption1.java:142:45:142:56 | Key | +| jca/Encryption1.java:143:34:143:71 | EncryptOperation | +| jca/Encryption1.java:143:34:143:71 | KeyOperationOutput | +| jca/Encryption1.java:143:52:143:70 | Message | +| jca/Encryption1.java:159:34:159:55 | Parameter | +| jca/Encryption1.java:159:58:159:68 | Parameter | +| jca/Encryption1.java:161:56:161:60 | KeyOperationAlgorithm | +| jca/Encryption1.java:162:21:162:23 | Constant | +| jca/Encryption1.java:163:28:163:47 | Key | +| jca/Encryption1.java:163:28:163:47 | KeyGeneration | +| jca/Encryption1.java:166:47:166:85 | HashAlgorithm | +| jca/Encryption1.java:166:47:166:85 | KeyOperationAlgorithm | +| jca/Encryption1.java:166:47:166:85 | ModeOfOperation | +| jca/Encryption1.java:166:47:166:85 | PaddingAlgorithm | +| jca/Encryption1.java:167:45:167:56 | Key | +| jca/Encryption1.java:168:34:168:71 | EncryptOperation | +| jca/Encryption1.java:168:34:168:71 | KeyOperationOutput | +| jca/Encryption1.java:168:52:168:70 | Message | +| jca/Encryption1.java:171:47:171:65 | KeyOperationAlgorithm | +| jca/Encryption1.java:171:47:171:65 | ModeOfOperation | +| jca/Encryption1.java:171:47:171:65 | PaddingAlgorithm | +| jca/Encryption1.java:173:9:173:40 | RandomNumberGeneration | +| jca/Encryption1.java:173:38:173:39 | RandomNumberGeneration | +| jca/Encryption1.java:175:45:175:50 | Key | +| jca/Encryption1.java:175:53:175:59 | Nonce | +| jca/Encryption1.java:176:32:176:65 | EncryptOperation | +| jca/Encryption1.java:176:32:176:65 | KeyOperationOutput | +| jca/Encryption1.java:176:50:176:64 | Message | +| jca/Encryption2.java:55:60:55:70 | EllipticCurve | +| jca/Encryption2.java:56:16:56:49 | Key | +| jca/Encryption2.java:56:16:56:49 | KeyGeneration | +| jca/Encryption2.java:71:62:71:67 | KeyAgreementAlgorithm | +| jca/Encryption2.java:72:27:72:36 | Key | +| jca/Encryption2.java:73:30:73:38 | Key | +| jca/Encryption2.java:74:16:74:44 | KeyAgreementOperation | +| jca/Encryption2.java:74:16:74:44 | SharedSecret | +| jca/Encryption2.java:90:38:90:65 | Parameter | +| jca/Encryption2.java:90:68:90:78 | Parameter | +| jca/Encryption2.java:99:58:99:66 | HashAlgorithm | +| jca/Encryption2.java:100:30:100:56 | Digest | +| jca/Encryption2.java:100:30:100:56 | HashOperation | +| jca/Encryption2.java:100:44:100:55 | Message | +| jca/Encryption2.java:105:47:105:65 | KeyOperationAlgorithm | +| jca/Encryption2.java:105:47:105:65 | ModeOfOperation | +| jca/Encryption2.java:105:47:105:65 | PaddingAlgorithm | +| jca/Encryption2.java:107:9:107:40 | RandomNumberGeneration | +| jca/Encryption2.java:107:38:107:39 | RandomNumberGeneration | +| jca/Encryption2.java:109:45:109:50 | Key | +| jca/Encryption2.java:109:53:109:59 | Nonce | +| jca/Encryption2.java:110:32:110:65 | EncryptOperation | +| jca/Encryption2.java:110:32:110:65 | KeyOperationOutput | +| jca/Encryption2.java:110:50:110:64 | Message | +| jca/Encryption2.java:132:45:132:65 | Parameter | +| jca/Encryption2.java:132:68:132:88 | Parameter | +| jca/Encryption2.java:145:47:145:65 | KeyOperationAlgorithm | +| jca/Encryption2.java:145:47:145:65 | ModeOfOperation | +| jca/Encryption2.java:145:47:145:65 | PaddingAlgorithm | +| jca/Encryption2.java:147:9:147:40 | RandomNumberGeneration | +| jca/Encryption2.java:147:38:147:39 | RandomNumberGeneration | +| jca/Encryption2.java:149:45:149:50 | Key | +| jca/Encryption2.java:149:53:149:59 | Nonce | +| jca/Encryption2.java:150:32:150:98 | EncryptOperation | +| jca/Encryption2.java:150:32:150:98 | KeyOperationOutput | +| jca/Encryption2.java:150:50:150:86 | Constant | +| jca/Encryption2.java:150:50:150:97 | Message | +| jca/Encryption2.java:173:36:173:47 | KeyOperationAlgorithm | +| jca/Encryption2.java:175:19:175:27 | Key | +| jca/Encryption2.java:176:31:176:52 | KeyOperationOutput | +| jca/Encryption2.java:176:31:176:52 | MACOperation | +| jca/Encryption2.java:176:44:176:51 | Message | +| jca/Hash.java:75:58:75:66 | HashAlgorithm | +| jca/Hash.java:76:23:76:66 | Digest | +| jca/Hash.java:76:23:76:66 | HashOperation | +| jca/Hash.java:76:37:76:54 | Constant | +| jca/Hash.java:76:37:76:65 | Message | +| jca/Hash.java:88:61:88:65 | HashAlgorithm | +| jca/Hash.java:89:23:89:70 | Digest | +| jca/Hash.java:89:23:89:70 | HashOperation | +| jca/Hash.java:89:40:89:58 | Constant | +| jca/Hash.java:89:40:89:69 | Message | +| jca/Hash.java:133:29:133:40 | Parameter | +| jca/Hash.java:133:43:133:63 | Parameter | +| jca/Hash.java:134:53:134:67 | HashAlgorithm | +| jca/Hash.java:134:53:134:67 | KeyOperationAlgorithm | +| jca/Hash.java:135:28:135:37 | Key | +| jca/Hash.java:136:26:136:41 | Message | +| jca/Hash.java:137:29:137:44 | SignOperation | +| jca/Hash.java:137:29:137:44 | SignatureOutput | +| jca/Hash.java:154:40:154:51 | Parameter | +| jca/Hash.java:154:54:154:70 | Parameter | +| jca/Hash.java:154:73:154:91 | Parameter | +| jca/Hash.java:155:53:155:67 | HashAlgorithm | +| jca/Hash.java:155:53:155:67 | KeyOperationAlgorithm | +| jca/Hash.java:156:30:156:38 | Key | +| jca/Hash.java:157:26:157:41 | Message | +| jca/Hash.java:158:16:158:43 | VerifyOperation | +| jca/Hash.java:158:33:158:42 | SignatureInput | +| jca/Hash.java:172:43:172:53 | Parameter | +| jca/Hash.java:173:58:173:66 | HashAlgorithm | +| jca/Hash.java:174:23:174:52 | Digest | +| jca/Hash.java:174:23:174:52 | HashOperation | +| jca/Hash.java:174:37:174:51 | Message | +| jca/Hash.java:190:43:190:54 | Parameter | +| jca/Hash.java:191:32:191:38 | HashAlgorithm | +| jca/Hash.java:191:41:191:49 | HashAlgorithm | +| jca/Hash.java:191:52:191:60 | HashAlgorithm | +| jca/Hash.java:191:63:191:71 | HashAlgorithm | +| jca/Hash.java:191:74:191:82 | HashAlgorithm | +| jca/Hash.java:191:85:191:94 | HashAlgorithm | +| jca/Hash.java:191:97:191:106 | HashAlgorithm | +| jca/Hash.java:192:13:192:25 | HashAlgorithm | +| jca/Hash.java:192:28:192:40 | HashAlgorithm | +| jca/Hash.java:192:43:192:47 | HashAlgorithm | +| jca/Hash.java:195:27:195:57 | Digest | +| jca/Hash.java:195:27:195:57 | HashOperation | +| jca/Hash.java:195:41:195:56 | Message | +| jca/Hash.java:211:43:211:54 | Parameter | +| jca/Hash.java:211:57:211:66 | Parameter | +| jca/Hash.java:212:32:212:41 | KeyOperationAlgorithm | +| jca/Hash.java:212:44:212:55 | KeyOperationAlgorithm | +| jca/Hash.java:212:58:212:69 | KeyOperationAlgorithm | +| jca/Hash.java:212:72:212:83 | KeyOperationAlgorithm | +| jca/Hash.java:212:86:212:99 | KeyOperationAlgorithm | +| jca/Hash.java:212:102:212:115 | KeyOperationAlgorithm | +| jca/Hash.java:216:22:216:30 | Key | +| jca/Hash.java:217:27:217:55 | KeyOperationOutput | +| jca/Hash.java:217:27:217:55 | MACOperation | +| jca/Hash.java:217:39:217:54 | Message | +| jca/Hash.java:232:40:232:54 | Parameter | +| jca/Hash.java:235:42:235:63 | Message | +| jca/Hash.java:235:66:235:69 | Salt | +| jca/Hash.java:235:72:235:76 | Constant | +| jca/Hash.java:235:79:235:81 | Constant | +| jca/Hash.java:236:65:236:86 | HMACAlgorithm | +| jca/Hash.java:236:65:236:86 | HashAlgorithm | +| jca/Hash.java:236:65:236:86 | KeyDerivationAlgorithm | +| jca/Hash.java:237:23:237:50 | Key | +| jca/Hash.java:237:23:237:50 | KeyDerivation | +| jca/Hash.java:252:23:252:70 | Digest | +| jca/Hash.java:252:23:252:70 | HashOperation | +| jca/Hash.java:252:37:252:58 | Constant | +| jca/Hash.java:252:37:252:69 | Message | +| jca/Hash.java:266:32:266:40 | HashAlgorithm | +| jca/Hash.java:266:43:266:51 | HashAlgorithm | +| jca/Hash.java:266:54:266:63 | HashAlgorithm | +| jca/Hash.java:266:66:266:75 | HashAlgorithm | +| jca/Hash.java:269:27:269:38 | Constant | +| jca/Hash.java:270:27:270:30 | Message | +| jca/Hash.java:271:40:271:54 | Digest | +| jca/Hash.java:271:40:271:54 | HashOperation | +| jca/Hash.java:294:16:294:66 | LocalData | +| jca/Hash.java:294:57:294:65 | HashAlgorithm | +| jca/Hash.java:310:9:310:42 | RandomNumberGeneration | +| jca/Hash.java:310:38:310:41 | RandomNumberGeneration | +| jca/IVArtifact.java:30:44:30:65 | KeyOperationAlgorithm | +| jca/IVArtifact.java:30:44:30:65 | ModeOfOperation | +| jca/IVArtifact.java:30:44:30:65 | PaddingAlgorithm | +| jca/IVArtifact.java:31:42:31:44 | Key | +| jca/IVArtifact.java:31:47:31:52 | Nonce | +| jca/IVArtifact.java:32:29:32:73 | EncryptOperation | +| jca/IVArtifact.java:32:29:32:73 | KeyOperationOutput | +| jca/IVArtifact.java:32:44:32:61 | Constant | +| jca/IVArtifact.java:32:44:32:72 | Message | +| jca/IVArtifact.java:38:42:38:44 | Key | +| jca/IVArtifact.java:38:47:38:52 | Nonce | +| jca/IVArtifact.java:39:29:39:53 | EncryptOperation | +| jca/IVArtifact.java:39:29:39:53 | KeyOperationOutput | +| jca/IVArtifact.java:39:44:39:52 | Message | +| jca/IVArtifact.java:49:27:49:42 | Constant | +| jca/IVArtifact.java:70:16:70:81 | LocalData | +| jca/IVArtifact.java:70:59:70:80 | KeyOperationAlgorithm | +| jca/IVArtifact.java:70:59:70:80 | ModeOfOperation | +| jca/IVArtifact.java:70:59:70:80 | PaddingAlgorithm | +| jca/IVArtifact.java:74:56:74:60 | KeyOperationAlgorithm | +| jca/IVArtifact.java:75:21:75:23 | Constant | +| jca/IVArtifact.java:76:16:76:35 | Key | +| jca/IVArtifact.java:76:16:76:35 | KeyGeneration | +| jca/IVArtifact.java:81:9:81:40 | RandomNumberGeneration | +| jca/IVArtifact.java:81:38:81:39 | RandomNumberGeneration | +| jca/IVArtifact.java:87:32:87:33 | RandomNumberGeneration | +| jca/IVArtifact.java:105:44:105:62 | KeyOperationAlgorithm | +| jca/IVArtifact.java:105:44:105:62 | ModeOfOperation | +| jca/IVArtifact.java:105:44:105:62 | PaddingAlgorithm | +| jca/IVArtifact.java:108:42:108:44 | Key | +| jca/IVArtifact.java:108:47:108:50 | Nonce | +| jca/IVArtifact.java:109:16:109:40 | EncryptOperation | +| jca/IVArtifact.java:109:16:109:40 | KeyOperationOutput | +| jca/IVArtifact.java:109:31:109:39 | Message | +| jca/IVArtifact.java:116:31:116:34 | Constant | +| jca/IVArtifact.java:130:13:130:50 | RandomNumberGeneration | +| jca/IVArtifact.java:130:42:130:49 | RandomNumberGeneration | +| jca/IVArtifact.java:132:44:132:62 | KeyOperationAlgorithm | +| jca/IVArtifact.java:132:44:132:62 | ModeOfOperation | +| jca/IVArtifact.java:132:44:132:62 | PaddingAlgorithm | +| jca/IVArtifact.java:134:42:134:44 | Key | +| jca/IVArtifact.java:134:47:134:50 | Nonce | +| jca/IVArtifact.java:135:16:135:40 | EncryptOperation | +| jca/IVArtifact.java:135:16:135:40 | KeyOperationOutput | +| jca/IVArtifact.java:135:31:135:39 | Message | +| jca/IVArtifact.java:153:58:153:66 | HashAlgorithm | +| jca/IVArtifact.java:154:31:154:78 | Digest | +| jca/IVArtifact.java:154:31:154:78 | HashOperation | +| jca/IVArtifact.java:154:45:154:59 | Constant | +| jca/IVArtifact.java:154:45:154:77 | Message | +| jca/IVArtifact.java:156:44:156:62 | KeyOperationAlgorithm | +| jca/IVArtifact.java:156:44:156:62 | ModeOfOperation | +| jca/IVArtifact.java:156:44:156:62 | PaddingAlgorithm | +| jca/IVArtifact.java:158:42:158:44 | Key | +| jca/IVArtifact.java:158:47:158:50 | Nonce | +| jca/IVArtifact.java:159:16:159:40 | EncryptOperation | +| jca/IVArtifact.java:159:16:159:40 | KeyOperationOutput | +| jca/IVArtifact.java:159:31:159:39 | Message | +| jca/IVArtifact.java:177:9:177:40 | RandomNumberGeneration | +| jca/IVArtifact.java:177:38:177:39 | RandomNumberGeneration | +| jca/IVArtifact.java:180:48:180:66 | KeyOperationAlgorithm | +| jca/IVArtifact.java:180:48:180:66 | ModeOfOperation | +| jca/IVArtifact.java:180:48:180:66 | PaddingAlgorithm | +| jca/IVArtifact.java:182:46:182:48 | Key | +| jca/IVArtifact.java:182:51:182:54 | Nonce | +| jca/IVArtifact.java:183:30:183:58 | EncryptOperation | +| jca/IVArtifact.java:183:30:183:58 | KeyOperationOutput | +| jca/IVArtifact.java:183:45:183:57 | Message | +| jca/IVArtifact.java:198:44:198:62 | KeyOperationAlgorithm | +| jca/IVArtifact.java:198:44:198:62 | ModeOfOperation | +| jca/IVArtifact.java:198:44:198:62 | PaddingAlgorithm | +| jca/IVArtifact.java:201:42:201:44 | Key | +| jca/IVArtifact.java:201:47:201:50 | Nonce | +| jca/IVArtifact.java:202:16:202:40 | EncryptOperation | +| jca/IVArtifact.java:202:16:202:40 | KeyOperationOutput | +| jca/IVArtifact.java:202:31:202:39 | Message | +| jca/IVArtifact.java:215:53:215:65 | Parameter | +| jca/IVArtifact.java:215:68:215:83 | Parameter | +| jca/IVArtifact.java:235:60:235:72 | Parameter | +| jca/IVArtifact.java:235:75:235:90 | Parameter | +| jca/IVArtifact.java:253:56:253:60 | KeyOperationAlgorithm | +| jca/IVArtifact.java:254:21:254:23 | Constant | +| jca/IVArtifact.java:255:29:255:44 | Key | +| jca/IVArtifact.java:255:29:255:44 | KeyGeneration | +| jca/IVArtifact.java:256:32:256:47 | Constant | +| jca/IVArtifact.java:275:34:275:46 | Constant | +| jca/IVArtifact.java:275:60:275:72 | Constant | +| jca/IVArtifact.java:275:86:275:100 | Constant | +| jca/KeyAgreementHybridCryptosystem.java:50:47:50:57 | EllipticCurve | +| jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | Key | +| jca/KeyAgreementHybridCryptosystem.java:51:16:51:36 | KeyGeneration | +| jca/KeyAgreementHybridCryptosystem.java:58:61:58:68 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:59:24:59:26 | Constant | +| jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | Key | +| jca/KeyAgreementHybridCryptosystem.java:60:16:60:36 | KeyGeneration | +| jca/KeyAgreementHybridCryptosystem.java:68:17:68:26 | Key | +| jca/KeyAgreementHybridCryptosystem.java:69:20:69:28 | Key | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | KeyAgreementOperation | +| jca/KeyAgreementHybridCryptosystem.java:70:16:70:34 | SharedSecret | +| jca/KeyAgreementHybridCryptosystem.java:78:58:78:66 | HashAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:79:23:79:42 | Digest | +| jca/KeyAgreementHybridCryptosystem.java:79:23:79:42 | HashOperation | +| jca/KeyAgreementHybridCryptosystem.java:79:37:79:41 | Message | +| jca/KeyAgreementHybridCryptosystem.java:104:90:104:95 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | ModeOfOperation | +| jca/KeyAgreementHybridCryptosystem.java:108:44:108:62 | PaddingAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:110:9:110:40 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:110:38:110:39 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:112:42:112:47 | Key | +| jca/KeyAgreementHybridCryptosystem.java:112:50:112:53 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | EncryptOperation | +| jca/KeyAgreementHybridCryptosystem.java:113:29:113:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:113:44:113:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:125:95:125:100 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | ModeOfOperation | +| jca/KeyAgreementHybridCryptosystem.java:130:44:130:62 | PaddingAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:132:42:132:47 | Key | +| jca/KeyAgreementHybridCryptosystem.java:132:50:132:53 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | EncryptOperation | +| jca/KeyAgreementHybridCryptosystem.java:133:29:133:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:133:44:133:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:149:91:149:98 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:150:33:150:89 | Digest | +| jca/KeyAgreementHybridCryptosystem.java:150:33:150:89 | HashOperation | +| jca/KeyAgreementHybridCryptosystem.java:150:59:150:67 | HashAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:150:77:150:88 | Message | +| jca/KeyAgreementHybridCryptosystem.java:153:44:153:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:155:9:155:43 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:155:38:155:42 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:156:42:156:50 | Key | +| jca/KeyAgreementHybridCryptosystem.java:156:53:156:78 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | EncryptOperation | +| jca/KeyAgreementHybridCryptosystem.java:157:29:157:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:157:44:157:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:169:95:169:102 | KeyAgreementAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:174:44:174:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:175:42:175:50 | Key | +| jca/KeyAgreementHybridCryptosystem.java:175:53:175:83 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | EncryptOperation | +| jca/KeyAgreementHybridCryptosystem.java:176:29:176:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:176:44:176:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:188:58:188:73 | Parameter | +| jca/KeyAgreementHybridCryptosystem.java:212:58:212:70 | Parameter | +| jca/KeyAgreementHybridCryptosystem.java:212:73:212:88 | Parameter | +| jca/KeyAgreementHybridCryptosystem.java:215:42:215:66 | Message | +| jca/KeyAgreementHybridCryptosystem.java:215:69:215:72 | Salt | +| jca/KeyAgreementHybridCryptosystem.java:215:75:215:79 | Constant | +| jca/KeyAgreementHybridCryptosystem.java:215:82:215:84 | Constant | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HMACAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | HashAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:216:65:216:86 | KeyDerivationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | Key | +| jca/KeyAgreementHybridCryptosystem.java:217:26:217:53 | KeyDerivation | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | ModeOfOperation | +| jca/KeyAgreementHybridCryptosystem.java:223:44:223:62 | PaddingAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:225:9:225:40 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:225:38:225:39 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:227:42:227:54 | Key | +| jca/KeyAgreementHybridCryptosystem.java:227:57:227:63 | Nonce | +| jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | EncryptOperation | +| jca/KeyAgreementHybridCryptosystem.java:228:29:228:53 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:228:44:228:52 | Message | +| jca/KeyAgreementHybridCryptosystem.java:230:35:230:46 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:231:18:231:30 | Key | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | KeyOperationOutput | +| jca/KeyAgreementHybridCryptosystem.java:232:30:232:52 | MACOperation | +| jca/KeyAgreementHybridCryptosystem.java:232:42:232:51 | Message | +| jca/KeyAgreementHybridCryptosystem.java:259:52:259:56 | KeyOperationAlgorithm | +| jca/KeyAgreementHybridCryptosystem.java:260:17:260:19 | Constant | +| jca/KeyAgreementHybridCryptosystem.java:261:16:261:31 | Key | +| jca/KeyAgreementHybridCryptosystem.java:261:16:261:31 | KeyGeneration | +| jca/KeyAgreementHybridCryptosystem.java:269:9:269:42 | RandomNumberGeneration | +| jca/KeyAgreementHybridCryptosystem.java:269:38:269:41 | RandomNumberGeneration | +| jca/KeyArtifact.java:18:56:18:60 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:19:21:19:23 | Constant | +| jca/KeyArtifact.java:20:31:20:50 | Key | +| jca/KeyArtifact.java:20:31:20:50 | KeyGeneration | +| jca/KeyArtifact.java:23:43:23:47 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:24:21:24:23 | Constant | +| jca/KeyArtifact.java:25:30:25:49 | Key | +| jca/KeyArtifact.java:25:30:25:49 | KeyGeneration | +| jca/KeyArtifact.java:30:68:30:72 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:31:31:31:34 | Constant | +| jca/KeyArtifact.java:32:30:32:57 | Key | +| jca/KeyArtifact.java:32:30:32:57 | KeyGeneration | +| jca/KeyArtifact.java:35:51:35:55 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:36:31:36:34 | Constant | +| jca/KeyArtifact.java:37:29:37:56 | Key | +| jca/KeyArtifact.java:37:29:37:56 | KeyGeneration | +| jca/KeyArtifact.java:41:31:41:33 | Constant | +| jca/KeyArtifact.java:42:26:42:53 | Key | +| jca/KeyArtifact.java:42:26:42:53 | KeyGeneration | +| jca/KeyArtifact.java:62:28:62:73 | LocalData | +| jca/KeyArtifact.java:62:68:62:72 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:65:21:65:23 | Constant | +| jca/KeyArtifact.java:66:32:66:51 | Key | +| jca/KeyArtifact.java:66:32:66:51 | KeyGeneration | +| jca/KeyArtifact.java:72:31:72:34 | Constant | +| jca/KeyArtifact.java:73:16:73:43 | Key | +| jca/KeyArtifact.java:73:16:73:43 | KeyGeneration | +| jca/KeyArtifact.java:78:32:78:36 | KeyOperationAlgorithm | +| jca/KeyArtifact.java:78:45:78:53 | Constant | +| jca/KeyDerivation1.java:78:39:78:53 | Parameter | +| jca/KeyDerivation1.java:80:42:80:63 | Message | +| jca/KeyDerivation1.java:80:66:80:69 | Salt | +| jca/KeyDerivation1.java:80:72:80:76 | Constant | +| jca/KeyDerivation1.java:80:79:80:81 | Constant | +| jca/KeyDerivation1.java:81:65:81:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:81:65:81:86 | HashAlgorithm | +| jca/KeyDerivation1.java:81:65:81:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:82:22:82:49 | Key | +| jca/KeyDerivation1.java:82:22:82:49 | KeyDerivation | +| jca/KeyDerivation1.java:92:36:92:50 | Parameter | +| jca/KeyDerivation1.java:94:42:94:63 | Message | +| jca/KeyDerivation1.java:94:66:94:69 | Salt | +| jca/KeyDerivation1.java:94:72:94:73 | Constant | +| jca/KeyDerivation1.java:94:76:94:78 | Constant | +| jca/KeyDerivation1.java:95:65:95:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:95:65:95:86 | HashAlgorithm | +| jca/KeyDerivation1.java:95:65:95:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:96:22:96:49 | Key | +| jca/KeyDerivation1.java:96:22:96:49 | KeyDerivation | +| jca/KeyDerivation1.java:106:37:106:51 | Parameter | +| jca/KeyDerivation1.java:108:42:108:63 | Message | +| jca/KeyDerivation1.java:108:66:108:69 | Salt | +| jca/KeyDerivation1.java:108:72:108:80 | Constant | +| jca/KeyDerivation1.java:108:83:108:85 | Constant | +| jca/KeyDerivation1.java:109:65:109:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:109:65:109:86 | HashAlgorithm | +| jca/KeyDerivation1.java:109:65:109:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:110:22:110:49 | Key | +| jca/KeyDerivation1.java:110:22:110:49 | KeyDerivation | +| jca/KeyDerivation1.java:120:32:120:46 | Parameter | +| jca/KeyDerivation1.java:122:42:122:63 | Message | +| jca/KeyDerivation1.java:122:66:122:69 | Salt | +| jca/KeyDerivation1.java:122:72:122:76 | Constant | +| jca/KeyDerivation1.java:122:79:122:81 | Constant | +| jca/KeyDerivation1.java:123:65:123:84 | HMACAlgorithm | +| jca/KeyDerivation1.java:123:65:123:84 | HashAlgorithm | +| jca/KeyDerivation1.java:123:65:123:84 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:124:22:124:49 | Key | +| jca/KeyDerivation1.java:124:22:124:49 | KeyDerivation | +| jca/KeyDerivation1.java:134:34:134:48 | Parameter | +| jca/KeyDerivation1.java:136:42:136:63 | Message | +| jca/KeyDerivation1.java:136:66:136:69 | Salt | +| jca/KeyDerivation1.java:136:72:136:77 | Constant | +| jca/KeyDerivation1.java:136:80:136:82 | Constant | +| jca/KeyDerivation1.java:137:65:137:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:137:65:137:86 | HashAlgorithm | +| jca/KeyDerivation1.java:137:65:137:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:138:22:138:49 | Key | +| jca/KeyDerivation1.java:138:22:138:49 | KeyDerivation | +| jca/KeyDerivation1.java:154:28:154:42 | Parameter | +| jca/KeyDerivation1.java:157:42:157:63 | Message | +| jca/KeyDerivation1.java:157:66:157:69 | Salt | +| jca/KeyDerivation1.java:157:72:157:75 | Constant | +| jca/KeyDerivation1.java:157:78:157:80 | Constant | +| jca/KeyDerivation1.java:158:65:158:72 | Constant | +| jca/KeyDerivation1.java:159:22:159:49 | Key | +| jca/KeyDerivation1.java:159:22:159:49 | KeyDerivation | +| jca/KeyDerivation1.java:169:30:169:44 | Parameter | +| jca/KeyDerivation1.java:172:42:172:63 | Message | +| jca/KeyDerivation1.java:172:66:172:69 | Salt | +| jca/KeyDerivation1.java:172:72:172:76 | Constant | +| jca/KeyDerivation1.java:172:79:172:81 | Constant | +| jca/KeyDerivation1.java:173:65:173:72 | Constant | +| jca/KeyDerivation1.java:174:22:174:49 | Key | +| jca/KeyDerivation1.java:174:22:174:49 | KeyDerivation | +| jca/KeyDerivation1.java:242:45:242:56 | Parameter | +| jca/KeyDerivation1.java:243:58:243:66 | HashAlgorithm | +| jca/KeyDerivation1.java:244:29:244:59 | Digest | +| jca/KeyDerivation1.java:244:29:244:59 | HashOperation | +| jca/KeyDerivation1.java:244:43:244:58 | Message | +| jca/KeyDerivation1.java:249:70:249:88 | KeyOperationAlgorithm | +| jca/KeyDerivation1.java:249:70:249:88 | ModeOfOperation | +| jca/KeyDerivation1.java:249:70:249:88 | PaddingAlgorithm | +| jca/KeyDerivation1.java:250:55:250:57 | Key | +| jca/KeyDerivation1.java:251:29:251:74 | EncryptOperation | +| jca/KeyDerivation1.java:251:29:251:74 | KeyOperationOutput | +| jca/KeyDerivation1.java:251:44:251:62 | Constant | +| jca/KeyDerivation1.java:251:44:251:73 | Message | +| jca/KeyDerivation1.java:269:32:269:41 | Parameter | +| jca/KeyDerivation1.java:283:43:283:57 | Parameter | +| jca/KeyDerivation1.java:283:60:283:78 | Parameter | +| jca/KeyDerivation1.java:302:37:302:51 | Parameter | +| jca/KeyDerivation1.java:309:25:309:76 | LocalData | +| jca/KeyDerivation1.java:309:54:309:75 | HMACAlgorithm | +| jca/KeyDerivation1.java:309:54:309:75 | HashAlgorithm | +| jca/KeyDerivation1.java:309:54:309:75 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:310:43:310:86 | LocalData | +| jca/KeyDerivation1.java:311:40:311:78 | LocalData | +| jca/KeyDerivation1.java:314:42:314:63 | Message | +| jca/KeyDerivation1.java:314:66:314:69 | Salt | +| jca/KeyDerivation1.java:316:26:316:53 | Key | +| jca/KeyDerivation1.java:316:26:316:53 | KeyDerivation | +| jca/KeyDerivation1.java:333:42:333:63 | Message | +| jca/KeyDerivation1.java:333:66:333:69 | Salt | +| jca/KeyDerivation1.java:333:72:333:76 | Constant | +| jca/KeyDerivation1.java:333:79:333:81 | Constant | +| jca/KeyDerivation1.java:334:65:334:86 | HMACAlgorithm | +| jca/KeyDerivation1.java:334:65:334:86 | HashAlgorithm | +| jca/KeyDerivation1.java:334:65:334:86 | KeyDerivationAlgorithm | +| jca/KeyDerivation1.java:335:16:335:43 | Key | +| jca/KeyDerivation1.java:335:16:335:43 | KeyDerivation | +| jca/KeyDerivation1.java:345:36:345:47 | KeyOperationAlgorithm | +| jca/KeyDerivation1.java:347:19:347:27 | Key | +| jca/KeyDerivation1.java:348:22:348:38 | KeyOperationOutput | +| jca/KeyDerivation1.java:348:22:348:38 | MACOperation | +| jca/KeyDerivation1.java:348:35:348:37 | Message | +| jca/KeyDerivation1.java:352:19:352:54 | Key | +| jca/KeyDerivation1.java:353:22:353:62 | KeyOperationOutput | +| jca/KeyDerivation1.java:353:22:353:62 | MACOperation | +| jca/KeyDerivation1.java:353:35:353:50 | Constant | +| jca/KeyDerivation1.java:353:35:353:61 | Message | +| jca/KeyDerivation1.java:365:9:365:42 | RandomNumberGeneration | +| jca/KeyDerivation1.java:365:38:365:41 | RandomNumberGeneration | +| jca/KeyEncapsulation.java:60:56:60:60 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:61:21:61:23 | Constant | +| jca/KeyEncapsulation.java:62:28:62:47 | Key | +| jca/KeyEncapsulation.java:62:28:62:47 | KeyGeneration | +| jca/KeyEncapsulation.java:67:47:67:85 | HashAlgorithm | +| jca/KeyEncapsulation.java:67:47:67:85 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:67:47:67:85 | ModeOfOperation | +| jca/KeyEncapsulation.java:67:47:67:85 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:68:45:68:50 | Key | +| jca/KeyEncapsulation.java:69:29:69:66 | EncryptOperation | +| jca/KeyEncapsulation.java:69:29:69:66 | KeyOperationOutput | +| jca/KeyEncapsulation.java:69:47:69:65 | Message | +| jca/KeyEncapsulation.java:73:47:73:65 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:73:47:73:65 | ModeOfOperation | +| jca/KeyEncapsulation.java:73:47:73:65 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:75:9:75:40 | RandomNumberGeneration | +| jca/KeyEncapsulation.java:75:38:75:39 | RandomNumberGeneration | +| jca/KeyEncapsulation.java:77:45:77:50 | Key | +| jca/KeyEncapsulation.java:77:53:77:59 | Nonce | +| jca/KeyEncapsulation.java:78:29:78:80 | EncryptOperation | +| jca/KeyEncapsulation.java:78:29:78:80 | KeyOperationOutput | +| jca/KeyEncapsulation.java:78:47:78:68 | Constant | +| jca/KeyEncapsulation.java:78:47:78:79 | Message | +| jca/KeyEncapsulation.java:91:37:91:54 | Parameter | +| jca/KeyEncapsulation.java:91:57:91:73 | Parameter | +| jca/KeyEncapsulation.java:92:47:92:85 | HashAlgorithm | +| jca/KeyEncapsulation.java:92:47:92:85 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:92:47:92:85 | ModeOfOperation | +| jca/KeyEncapsulation.java:92:47:92:85 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:93:45:93:51 | Key | +| jca/KeyEncapsulation.java:94:30:94:58 | DecryptOperation | +| jca/KeyEncapsulation.java:94:30:94:58 | KeyOperationOutput | +| jca/KeyEncapsulation.java:94:48:94:57 | Message | +| jca/KeyEncapsulation.java:117:47:117:57 | EllipticCurve | +| jca/KeyEncapsulation.java:118:31:118:51 | Key | +| jca/KeyEncapsulation.java:118:31:118:51 | KeyGeneration | +| jca/KeyEncapsulation.java:121:52:121:57 | KeyAgreementAlgorithm | +| jca/KeyEncapsulation.java:122:17:122:40 | Key | +| jca/KeyEncapsulation.java:123:20:123:24 | Key | +| jca/KeyEncapsulation.java:124:31:124:49 | KeyAgreementOperation | +| jca/KeyEncapsulation.java:124:31:124:49 | SharedSecret | +| jca/KeyEncapsulation.java:133:47:133:65 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:133:47:133:65 | ModeOfOperation | +| jca/KeyEncapsulation.java:133:47:133:65 | PaddingAlgorithm | +| jca/KeyEncapsulation.java:135:9:135:40 | RandomNumberGeneration | +| jca/KeyEncapsulation.java:135:38:135:39 | RandomNumberGeneration | +| jca/KeyEncapsulation.java:136:45:136:50 | Key | +| jca/KeyEncapsulation.java:136:53:136:81 | Nonce | +| jca/KeyEncapsulation.java:137:29:137:73 | EncryptOperation | +| jca/KeyEncapsulation.java:137:29:137:73 | KeyOperationOutput | +| jca/KeyEncapsulation.java:137:47:137:61 | Constant | +| jca/KeyEncapsulation.java:137:47:137:72 | Message | +| jca/KeyEncapsulation.java:186:47:186:57 | EllipticCurve | +| jca/KeyEncapsulation.java:187:31:187:51 | Key | +| jca/KeyEncapsulation.java:187:31:187:51 | KeyGeneration | +| jca/KeyEncapsulation.java:188:52:188:57 | KeyAgreementAlgorithm | +| jca/KeyEncapsulation.java:189:17:189:40 | Key | +| jca/KeyEncapsulation.java:190:20:190:34 | Key | +| jca/KeyEncapsulation.java:191:31:191:49 | KeyAgreementOperation | +| jca/KeyEncapsulation.java:191:31:191:49 | SharedSecret | +| jca/KeyEncapsulation.java:207:64:207:68 | KeyOperationAlgorithm | +| jca/KeyEncapsulation.java:208:27:208:30 | Constant | +| jca/KeyEncapsulation.java:209:25:209:48 | Key | +| jca/KeyEncapsulation.java:209:25:209:48 | KeyGeneration | +| jca/KeyEncapsulation.java:214:49:214:59 | EllipticCurve | +| jca/KeyEncapsulation.java:215:24:215:46 | Key | +| jca/KeyEncapsulation.java:215:24:215:46 | KeyGeneration | +| jca/KeyEncapsulation.java:226:31:226:53 | Key | +| jca/KeyEncapsulation.java:226:31:226:53 | KeyGeneration | +| jca/KeyExchange.java:52:63:52:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:53:26:53:29 | Constant | +| jca/KeyExchange.java:54:16:54:38 | Key | +| jca/KeyExchange.java:54:16:54:38 | KeyGeneration | +| jca/KeyExchange.java:67:63:67:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:69:26:69:28 | Constant | +| jca/KeyExchange.java:70:16:70:38 | Key | +| jca/KeyExchange.java:70:16:70:38 | KeyGeneration | +| jca/KeyExchange.java:83:63:83:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:84:26:84:29 | Constant | +| jca/KeyExchange.java:85:16:85:38 | Key | +| jca/KeyExchange.java:85:16:85:38 | KeyGeneration | +| jca/KeyExchange.java:99:52:99:55 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:100:17:100:26 | Key | +| jca/KeyExchange.java:101:20:101:28 | Key | +| jca/KeyExchange.java:102:16:102:34 | KeyAgreementOperation | +| jca/KeyExchange.java:102:16:102:34 | SharedSecret | +| jca/KeyExchange.java:121:49:121:59 | EllipticCurve | +| jca/KeyExchange.java:122:16:122:38 | Key | +| jca/KeyExchange.java:122:16:122:38 | KeyGeneration | +| jca/KeyExchange.java:136:52:136:57 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:137:17:137:26 | Key | +| jca/KeyExchange.java:138:20:138:28 | Key | +| jca/KeyExchange.java:139:16:139:34 | KeyAgreementOperation | +| jca/KeyExchange.java:139:16:139:34 | SharedSecret | +| jca/KeyExchange.java:156:61:156:68 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:158:24:158:26 | Constant | +| jca/KeyExchange.java:159:16:159:36 | Key | +| jca/KeyExchange.java:159:16:159:36 | KeyGeneration | +| jca/KeyExchange.java:173:52:173:59 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:174:17:174:26 | Key | +| jca/KeyExchange.java:175:20:175:28 | Key | +| jca/KeyExchange.java:176:16:176:34 | KeyAgreementOperation | +| jca/KeyExchange.java:176:16:176:34 | SharedSecret | +| jca/KeyExchange.java:193:61:193:66 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:195:24:195:26 | Constant | +| jca/KeyExchange.java:196:16:196:36 | Key | +| jca/KeyExchange.java:196:16:196:36 | KeyGeneration | +| jca/KeyExchange.java:210:52:210:57 | KeyAgreementAlgorithm | +| jca/KeyExchange.java:211:17:211:26 | Key | +| jca/KeyExchange.java:212:20:212:28 | Key | +| jca/KeyExchange.java:213:16:213:34 | KeyAgreementOperation | +| jca/KeyExchange.java:213:16:213:34 | SharedSecret | +| jca/MACOperation.java:59:36:59:49 | Parameter | +| jca/MACOperation.java:59:52:59:61 | Parameter | +| jca/MACOperation.java:60:35:60:46 | KeyOperationAlgorithm | +| jca/MACOperation.java:62:18:62:26 | Key | +| jca/MACOperation.java:63:16:63:46 | KeyOperationOutput | +| jca/MACOperation.java:63:16:63:46 | MACOperation | +| jca/MACOperation.java:63:28:63:45 | Message | +| jca/MACOperation.java:70:34:70:47 | Parameter | +| jca/MACOperation.java:70:50:70:59 | Parameter | +| jca/MACOperation.java:71:35:71:48 | KeyOperationAlgorithm | +| jca/MACOperation.java:73:18:73:26 | Key | +| jca/MACOperation.java:74:16:74:46 | KeyOperationOutput | +| jca/MACOperation.java:74:16:74:46 | MACOperation | +| jca/MACOperation.java:74:28:74:45 | Message | +| jca/MACOperation.java:81:34:81:47 | Parameter | +| jca/MACOperation.java:81:50:81:59 | Parameter | +| jca/MACOperation.java:82:35:82:44 | KeyOperationAlgorithm | +| jca/MACOperation.java:84:18:84:26 | Key | +| jca/MACOperation.java:85:16:85:46 | KeyOperationOutput | +| jca/MACOperation.java:85:16:85:46 | MACOperation | +| jca/MACOperation.java:85:28:85:45 | Message | +| jca/MACOperation.java:92:30:92:43 | Parameter | +| jca/MACOperation.java:92:46:92:55 | Parameter | +| jca/MACOperation.java:94:35:94:40 | KeyOperationAlgorithm | +| jca/MACOperation.java:98:18:98:26 | Key | +| jca/MACOperation.java:99:16:99:46 | KeyOperationOutput | +| jca/MACOperation.java:99:16:99:46 | MACOperation | +| jca/MACOperation.java:99:28:99:45 | Message | +| jca/MACOperation.java:106:30:106:43 | Parameter | +| jca/MACOperation.java:106:46:106:55 | Parameter | +| jca/MACOperation.java:107:35:107:43 | Constant | +| jca/MACOperation.java:109:18:109:26 | Key | +| jca/MACOperation.java:110:16:110:46 | KeyOperationOutput | +| jca/MACOperation.java:110:16:110:46 | MACOperation | +| jca/MACOperation.java:110:28:110:45 | Message | +| jca/MACOperation.java:117:36:117:49 | Parameter | +| jca/MACOperation.java:117:52:117:61 | Parameter | +| jca/MACOperation.java:118:35:118:44 | KeyOperationAlgorithm | +| jca/MACOperation.java:120:18:120:26 | Key | +| jca/MACOperation.java:121:16:121:46 | KeyOperationOutput | +| jca/MACOperation.java:121:16:121:46 | MACOperation | +| jca/MACOperation.java:121:28:121:45 | Message | +| jca/MACOperation.java:133:34:133:49 | Parameter | +| jca/MACOperation.java:136:44:136:62 | KeyOperationAlgorithm | +| jca/MACOperation.java:136:44:136:62 | ModeOfOperation | +| jca/MACOperation.java:136:44:136:62 | PaddingAlgorithm | +| jca/MACOperation.java:137:42:137:44 | Key | +| jca/MACOperation.java:138:32:138:74 | EncryptOperation | +| jca/MACOperation.java:138:32:138:74 | KeyOperationOutput | +| jca/MACOperation.java:138:47:138:62 | Constant | +| jca/MACOperation.java:138:47:138:73 | Message | +| jca/MACOperation.java:150:36:150:51 | Parameter | +| jca/MACOperation.java:166:47:166:62 | Parameter | +| jca/MACOperation.java:170:42:170:68 | Message | +| jca/MACOperation.java:170:71:170:74 | Salt | +| jca/MACOperation.java:170:77:170:81 | Constant | +| jca/MACOperation.java:170:84:170:86 | Constant | +| jca/MACOperation.java:171:65:171:86 | HMACAlgorithm | +| jca/MACOperation.java:171:65:171:86 | HashAlgorithm | +| jca/MACOperation.java:171:65:171:86 | KeyDerivationAlgorithm | +| jca/MACOperation.java:172:30:172:57 | Key | +| jca/MACOperation.java:172:30:172:57 | KeyDerivation | +| jca/MACOperation.java:180:44:180:62 | KeyOperationAlgorithm | +| jca/MACOperation.java:180:44:180:62 | ModeOfOperation | +| jca/MACOperation.java:180:44:180:62 | PaddingAlgorithm | +| jca/MACOperation.java:181:42:181:54 | Key | +| jca/MACOperation.java:182:29:182:78 | EncryptOperation | +| jca/MACOperation.java:182:29:182:78 | KeyOperationOutput | +| jca/MACOperation.java:182:44:182:66 | Constant | +| jca/MACOperation.java:182:44:182:77 | Message | +| jca/MACOperation.java:185:35:185:46 | KeyOperationAlgorithm | +| jca/MACOperation.java:186:18:186:30 | Key | +| jca/MACOperation.java:187:30:187:52 | KeyOperationOutput | +| jca/MACOperation.java:187:30:187:52 | MACOperation | +| jca/MACOperation.java:187:42:187:51 | Message | +| jca/MACOperation.java:216:44:216:62 | KeyOperationAlgorithm | +| jca/MACOperation.java:216:44:216:62 | ModeOfOperation | +| jca/MACOperation.java:216:44:216:62 | PaddingAlgorithm | +| jca/MACOperation.java:218:42:218:44 | Key | +| jca/MACOperation.java:219:32:219:51 | EncryptOperation | +| jca/MACOperation.java:219:32:219:51 | KeyOperationOutput | +| jca/MACOperation.java:219:47:219:50 | Message | +| jca/MACOperation.java:232:56:232:60 | KeyOperationAlgorithm | +| jca/MACOperation.java:233:21:233:23 | Constant | +| jca/MACOperation.java:234:16:234:35 | Key | +| jca/MACOperation.java:234:16:234:35 | KeyGeneration | +| jca/MACOperation.java:246:9:246:42 | RandomNumberGeneration | +| jca/MACOperation.java:246:38:246:41 | RandomNumberGeneration | +| jca/Nonce.java:24:35:24:46 | KeyOperationAlgorithm | +| jca/Nonce.java:25:18:25:20 | Key | +| jca/Nonce.java:27:28:27:69 | KeyOperationOutput | +| jca/Nonce.java:27:28:27:69 | MACOperation | +| jca/Nonce.java:27:40:27:57 | Constant | +| jca/Nonce.java:27:40:27:68 | Message | +| jca/Nonce.java:37:35:37:46 | KeyOperationAlgorithm | +| jca/Nonce.java:38:18:38:20 | Key | +| jca/Nonce.java:40:28:40:67 | KeyOperationOutput | +| jca/Nonce.java:40:28:40:67 | MACOperation | +| jca/Nonce.java:40:40:40:55 | Constant | +| jca/Nonce.java:40:40:40:66 | Message | +| jca/Nonce.java:47:39:47:51 | Parameter | +| jca/Nonce.java:47:54:47:69 | Parameter | +| jca/Nonce.java:50:44:50:62 | KeyOperationAlgorithm | +| jca/Nonce.java:50:44:50:62 | ModeOfOperation | +| jca/Nonce.java:50:44:50:62 | PaddingAlgorithm | +| jca/Nonce.java:51:42:51:44 | Key | +| jca/Nonce.java:51:47:51:53 | Nonce | +| jca/Nonce.java:52:29:52:53 | EncryptOperation | +| jca/Nonce.java:52:29:52:53 | KeyOperationOutput | +| jca/Nonce.java:52:44:52:52 | Message | +| jca/Nonce.java:58:37:58:49 | Parameter | +| jca/Nonce.java:58:52:58:67 | Parameter | +| jca/Nonce.java:61:44:61:62 | KeyOperationAlgorithm | +| jca/Nonce.java:61:44:61:62 | ModeOfOperation | +| jca/Nonce.java:61:44:61:62 | PaddingAlgorithm | +| jca/Nonce.java:62:42:62:44 | Key | +| jca/Nonce.java:62:47:62:53 | Nonce | +| jca/Nonce.java:63:29:63:53 | EncryptOperation | +| jca/Nonce.java:63:29:63:53 | KeyOperationOutput | +| jca/Nonce.java:63:44:63:52 | Message | +| jca/Nonce.java:70:53:70:64 | KeyOperationAlgorithm | +| jca/Nonce.java:78:18:78:20 | Key | +| jca/Nonce.java:80:28:80:67 | KeyOperationOutput | +| jca/Nonce.java:80:28:80:67 | MACOperation | +| jca/Nonce.java:80:40:80:55 | Constant | +| jca/Nonce.java:80:40:80:66 | Message | +| jca/Nonce.java:92:56:92:67 | Constant | +| jca/Nonce.java:93:16:93:35 | Key | +| jca/Nonce.java:93:16:93:35 | KeyGeneration | +| jca/Nonce.java:98:9:98:43 | RandomNumberGeneration | +| jca/Nonce.java:98:38:98:42 | RandomNumberGeneration | +| jca/Nonce.java:112:16:112:33 | Constant | +| jca/PrngTest.java:152:56:152:60 | KeyOperationAlgorithm | +| jca/PrngTest.java:153:21:153:23 | Constant | +| jca/PrngTest.java:154:16:154:35 | Key | +| jca/PrngTest.java:154:16:154:35 | KeyGeneration | +| jca/SignEncryptCombinations.java:52:49:52:59 | EllipticCurve | +| jca/SignEncryptCombinations.java:53:16:53:38 | Key | +| jca/SignEncryptCombinations.java:53:16:53:38 | KeyGeneration | +| jca/SignEncryptCombinations.java:61:53:61:69 | HashAlgorithm | +| jca/SignEncryptCombinations.java:61:53:61:69 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:62:28:62:34 | Key | +| jca/SignEncryptCombinations.java:63:26:63:29 | Message | +| jca/SignEncryptCombinations.java:64:16:64:31 | SignOperation | +| jca/SignEncryptCombinations.java:64:16:64:31 | SignatureOutput | +| jca/SignEncryptCombinations.java:68:53:68:69 | HashAlgorithm | +| jca/SignEncryptCombinations.java:68:53:68:69 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:69:30:69:35 | Key | +| jca/SignEncryptCombinations.java:70:26:70:29 | Message | +| jca/SignEncryptCombinations.java:71:16:71:47 | VerifyOperation | +| jca/SignEncryptCombinations.java:71:33:71:46 | SignatureInput | +| jca/SignEncryptCombinations.java:82:52:82:56 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:83:17:83:19 | Constant | +| jca/SignEncryptCombinations.java:84:16:84:31 | Key | +| jca/SignEncryptCombinations.java:84:16:84:31 | KeyGeneration | +| jca/SignEncryptCombinations.java:92:44:92:62 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:92:44:92:62 | ModeOfOperation | +| jca/SignEncryptCombinations.java:92:44:92:62 | PaddingAlgorithm | +| jca/SignEncryptCombinations.java:94:9:94:28 | RandomNumberGeneration | +| jca/SignEncryptCombinations.java:94:26:94:27 | RandomNumberGeneration | +| jca/SignEncryptCombinations.java:96:42:96:44 | Key | +| jca/SignEncryptCombinations.java:96:47:96:50 | Nonce | +| jca/SignEncryptCombinations.java:97:29:97:53 | EncryptOperation | +| jca/SignEncryptCombinations.java:97:29:97:53 | KeyOperationOutput | +| jca/SignEncryptCombinations.java:97:44:97:52 | Message | +| jca/SignEncryptCombinations.java:111:44:111:62 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:111:44:111:62 | ModeOfOperation | +| jca/SignEncryptCombinations.java:111:44:111:62 | PaddingAlgorithm | +| jca/SignEncryptCombinations.java:112:42:112:44 | Key | +| jca/SignEncryptCombinations.java:112:47:112:75 | Nonce | +| jca/SignEncryptCombinations.java:113:16:113:41 | DecryptOperation | +| jca/SignEncryptCombinations.java:113:16:113:41 | KeyOperationOutput | +| jca/SignEncryptCombinations.java:113:31:113:40 | Message | +| jca/SignEncryptCombinations.java:121:35:121:46 | KeyOperationAlgorithm | +| jca/SignEncryptCombinations.java:122:18:122:20 | Key | +| jca/SignEncryptCombinations.java:123:16:123:32 | KeyOperationOutput | +| jca/SignEncryptCombinations.java:123:16:123:32 | MACOperation | +| jca/SignEncryptCombinations.java:123:28:123:31 | Message | +| jca/SignEncryptCombinations.java:335:26:335:47 | Constant | +| jca/SignatureOperation.java:52:61:52:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:53:24:53:27 | Constant | +| jca/SignatureOperation.java:54:16:54:36 | Key | +| jca/SignatureOperation.java:54:16:54:36 | KeyGeneration | +| jca/SignatureOperation.java:63:53:63:74 | HashAlgorithm | +| jca/SignatureOperation.java:63:53:63:74 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:64:28:64:37 | Key | +| jca/SignatureOperation.java:65:26:65:29 | Message | +| jca/SignatureOperation.java:66:16:66:31 | SignOperation | +| jca/SignatureOperation.java:66:16:66:31 | SignatureOutput | +| jca/SignatureOperation.java:75:53:75:74 | HashAlgorithm | +| jca/SignatureOperation.java:75:53:75:74 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:76:30:76:38 | Key | +| jca/SignatureOperation.java:77:26:77:29 | Message | +| jca/SignatureOperation.java:78:16:78:41 | VerifyOperation | +| jca/SignatureOperation.java:78:33:78:40 | SignatureInput | +| jca/SignatureOperation.java:93:49:93:59 | EllipticCurve | +| jca/SignatureOperation.java:94:16:94:38 | Key | +| jca/SignatureOperation.java:94:16:94:38 | KeyGeneration | +| jca/SignatureOperation.java:103:53:103:69 | HashAlgorithm | +| jca/SignatureOperation.java:103:53:103:69 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:104:28:104:37 | Key | +| jca/SignatureOperation.java:105:26:105:29 | Message | +| jca/SignatureOperation.java:106:16:106:31 | SignOperation | +| jca/SignatureOperation.java:106:16:106:31 | SignatureOutput | +| jca/SignatureOperation.java:115:53:115:69 | HashAlgorithm | +| jca/SignatureOperation.java:115:53:115:69 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:116:30:116:38 | Key | +| jca/SignatureOperation.java:117:26:117:29 | Message | +| jca/SignatureOperation.java:118:16:118:41 | VerifyOperation | +| jca/SignatureOperation.java:118:33:118:40 | SignatureInput | +| jca/SignatureOperation.java:132:61:132:69 | Constant | +| jca/SignatureOperation.java:133:16:133:36 | Key | +| jca/SignatureOperation.java:133:16:133:36 | KeyGeneration | +| jca/SignatureOperation.java:142:53:142:61 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:143:28:143:37 | Key | +| jca/SignatureOperation.java:144:26:144:29 | Message | +| jca/SignatureOperation.java:145:16:145:31 | SignOperation | +| jca/SignatureOperation.java:145:16:145:31 | SignatureOutput | +| jca/SignatureOperation.java:154:53:154:61 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:155:30:155:38 | Key | +| jca/SignatureOperation.java:156:26:156:29 | Message | +| jca/SignatureOperation.java:157:16:157:41 | VerifyOperation | +| jca/SignatureOperation.java:157:33:157:40 | SignatureInput | +| jca/SignatureOperation.java:173:61:173:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:174:24:174:27 | Constant | +| jca/SignatureOperation.java:175:16:175:36 | Key | +| jca/SignatureOperation.java:175:16:175:36 | KeyGeneration | +| jca/SignatureOperation.java:185:53:185:65 | HashAlgorithm | +| jca/SignatureOperation.java:185:53:185:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:186:28:186:37 | Key | +| jca/SignatureOperation.java:187:26:187:29 | Message | +| jca/SignatureOperation.java:188:16:188:31 | SignOperation | +| jca/SignatureOperation.java:188:16:188:31 | SignatureOutput | +| jca/SignatureOperation.java:198:53:198:65 | HashAlgorithm | +| jca/SignatureOperation.java:198:53:198:65 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:199:30:199:38 | Key | +| jca/SignatureOperation.java:200:26:200:29 | Message | +| jca/SignatureOperation.java:201:16:201:41 | VerifyOperation | +| jca/SignatureOperation.java:201:33:201:40 | SignatureInput | +| jca/SignatureOperation.java:231:26:231:44 | Constant | +| jca/SignatureOperation.java:236:27:236:30 | Constant | +| jca/SignatureOperation.java:266:47:266:68 | HashAlgorithm | +| jca/SignatureOperation.java:266:47:266:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:269:47:269:63 | HashAlgorithm | +| jca/SignatureOperation.java:269:47:269:63 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:272:47:272:55 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:275:47:275:59 | HashAlgorithm | +| jca/SignatureOperation.java:275:47:275:59 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:279:47:279:68 | HashAlgorithm | +| jca/SignatureOperation.java:279:47:279:68 | KeyOperationAlgorithm | +| jca/SignatureOperation.java:282:26:282:49 | Constant | +| jca/SignatureOperation.java:283:28:283:42 | Key | +| jca/SignatureOperation.java:284:26:284:32 | Message | +| jca/SignatureOperation.java:285:27:285:42 | SignOperation | +| jca/SignatureOperation.java:285:27:285:42 | SignatureOutput | +| jca/SignatureOperation.java:287:30:287:43 | Key | +| jca/SignatureOperation.java:288:26:288:32 | Message | +| jca/SignatureOperation.java:289:28:289:53 | VerifyOperation | +| jca/SignatureOperation.java:289:45:289:52 | SignatureInput | +| jca/SignatureOperation.java:311:26:311:49 | Constant | +| jca/SymmetricAlgorithm.java:51:44:51:62 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:51:44:51:62 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:51:44:51:62 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:53:9:53:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:53:38:53:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:55:42:55:44 | Key | +| jca/SymmetricAlgorithm.java:55:47:55:50 | Nonce | +| jca/SymmetricAlgorithm.java:56:29:56:53 | EncryptOperation | +| jca/SymmetricAlgorithm.java:56:29:56:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:56:44:56:52 | Message | +| jca/SymmetricAlgorithm.java:72:39:72:51 | Parameter | +| jca/SymmetricAlgorithm.java:72:54:72:69 | Parameter | +| jca/SymmetricAlgorithm.java:73:44:73:62 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:73:44:73:62 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:73:44:73:62 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:76:42:76:44 | Key | +| jca/SymmetricAlgorithm.java:76:47:76:50 | Nonce | +| jca/SymmetricAlgorithm.java:77:29:77:53 | EncryptOperation | +| jca/SymmetricAlgorithm.java:77:29:77:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:77:44:77:52 | Message | +| jca/SymmetricAlgorithm.java:94:44:94:65 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:94:44:94:65 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:94:44:94:65 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:96:9:96:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:96:38:96:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:98:42:98:44 | Key | +| jca/SymmetricAlgorithm.java:98:47:98:52 | Nonce | +| jca/SymmetricAlgorithm.java:99:29:99:53 | EncryptOperation | +| jca/SymmetricAlgorithm.java:99:29:99:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:99:44:99:52 | Message | +| jca/SymmetricAlgorithm.java:116:44:116:65 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:116:44:116:65 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:116:44:116:65 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:117:42:117:44 | Key | +| jca/SymmetricAlgorithm.java:118:16:118:40 | EncryptOperation | +| jca/SymmetricAlgorithm.java:118:16:118:40 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:118:31:118:39 | Message | +| jca/SymmetricAlgorithm.java:131:44:131:48 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:132:42:132:44 | Key | +| jca/SymmetricAlgorithm.java:133:16:133:40 | EncryptOperation | +| jca/SymmetricAlgorithm.java:133:16:133:40 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:133:31:133:39 | Message | +| jca/SymmetricAlgorithm.java:145:36:145:48 | Parameter | +| jca/SymmetricAlgorithm.java:145:51:145:66 | Parameter | +| jca/SymmetricAlgorithm.java:146:44:146:65 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:146:44:146:65 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:146:44:146:65 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:148:9:148:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:148:38:148:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:150:42:150:44 | Key | +| jca/SymmetricAlgorithm.java:150:47:150:52 | Nonce | +| jca/SymmetricAlgorithm.java:151:29:151:53 | EncryptOperation | +| jca/SymmetricAlgorithm.java:151:29:151:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:151:44:151:52 | Message | +| jca/SymmetricAlgorithm.java:167:42:167:54 | Parameter | +| jca/SymmetricAlgorithm.java:167:57:167:72 | Parameter | +| jca/SymmetricAlgorithm.java:168:44:168:68 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:168:44:168:68 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:168:44:168:68 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:170:9:170:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:170:38:170:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:172:42:172:44 | Key | +| jca/SymmetricAlgorithm.java:172:47:172:52 | Nonce | +| jca/SymmetricAlgorithm.java:173:29:173:53 | EncryptOperation | +| jca/SymmetricAlgorithm.java:173:29:173:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:173:44:173:52 | Message | +| jca/SymmetricAlgorithm.java:190:44:190:53 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:192:9:192:43 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:192:38:192:42 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:194:42:194:44 | Key | +| jca/SymmetricAlgorithm.java:194:47:194:72 | Nonce | +| jca/SymmetricAlgorithm.java:195:29:195:53 | EncryptOperation | +| jca/SymmetricAlgorithm.java:195:29:195:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:195:44:195:52 | Message | +| jca/SymmetricAlgorithm.java:212:35:212:47 | Parameter | +| jca/SymmetricAlgorithm.java:212:50:212:65 | Parameter | +| jca/SymmetricAlgorithm.java:213:36:213:44 | Constant | +| jca/SymmetricAlgorithm.java:214:19:214:21 | Key | +| jca/SymmetricAlgorithm.java:215:29:215:51 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:215:29:215:51 | MACOperation | +| jca/SymmetricAlgorithm.java:215:42:215:50 | Message | +| jca/SymmetricAlgorithm.java:218:44:218:62 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:218:44:218:62 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:218:44:218:62 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:220:9:220:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:220:38:220:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:222:42:222:51 | Key | +| jca/SymmetricAlgorithm.java:222:54:222:57 | Nonce | +| jca/SymmetricAlgorithm.java:223:29:223:53 | EncryptOperation | +| jca/SymmetricAlgorithm.java:223:29:223:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:223:44:223:52 | Message | +| jca/SymmetricAlgorithm.java:244:64:244:76 | Parameter | +| jca/SymmetricAlgorithm.java:244:79:244:94 | Parameter | +| jca/SymmetricAlgorithm.java:284:58:284:70 | Parameter | +| jca/SymmetricAlgorithm.java:284:73:284:88 | Parameter | +| jca/SymmetricAlgorithm.java:287:42:287:66 | Message | +| jca/SymmetricAlgorithm.java:287:69:287:72 | Salt | +| jca/SymmetricAlgorithm.java:287:75:287:79 | Constant | +| jca/SymmetricAlgorithm.java:287:82:287:84 | Constant | +| jca/SymmetricAlgorithm.java:288:65:288:86 | HMACAlgorithm | +| jca/SymmetricAlgorithm.java:288:65:288:86 | HashAlgorithm | +| jca/SymmetricAlgorithm.java:288:65:288:86 | KeyDerivationAlgorithm | +| jca/SymmetricAlgorithm.java:289:26:289:53 | Key | +| jca/SymmetricAlgorithm.java:289:26:289:53 | KeyDerivation | +| jca/SymmetricAlgorithm.java:295:44:295:62 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:295:44:295:62 | ModeOfOperation | +| jca/SymmetricAlgorithm.java:295:44:295:62 | PaddingAlgorithm | +| jca/SymmetricAlgorithm.java:297:9:297:40 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:297:38:297:39 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:298:42:298:47 | Key | +| jca/SymmetricAlgorithm.java:298:50:298:78 | Nonce | +| jca/SymmetricAlgorithm.java:299:29:299:53 | EncryptOperation | +| jca/SymmetricAlgorithm.java:299:29:299:53 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:299:44:299:52 | Message | +| jca/SymmetricAlgorithm.java:301:35:301:46 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:302:18:302:30 | Key | +| jca/SymmetricAlgorithm.java:303:30:303:52 | KeyOperationOutput | +| jca/SymmetricAlgorithm.java:303:30:303:52 | MACOperation | +| jca/SymmetricAlgorithm.java:303:42:303:51 | Message | +| jca/SymmetricAlgorithm.java:331:52:331:56 | KeyOperationAlgorithm | +| jca/SymmetricAlgorithm.java:332:17:332:19 | Constant | +| jca/SymmetricAlgorithm.java:333:16:333:31 | Key | +| jca/SymmetricAlgorithm.java:333:16:333:31 | KeyGeneration | +| jca/SymmetricAlgorithm.java:345:9:345:42 | RandomNumberGeneration | +| jca/SymmetricAlgorithm.java:345:38:345:41 | RandomNumberGeneration | +| jca/SymmetricModesTest.java:48:52:48:56 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:49:17:49:19 | Constant | +| jca/SymmetricModesTest.java:50:33:50:48 | Key | +| jca/SymmetricModesTest.java:50:33:50:48 | KeyGeneration | +| jca/SymmetricModesTest.java:53:17:53:19 | Constant | +| jca/SymmetricModesTest.java:54:31:54:46 | Key | +| jca/SymmetricModesTest.java:54:31:54:46 | KeyGeneration | +| jca/SymmetricModesTest.java:57:44:57:62 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:57:44:57:62 | ModeOfOperation | +| jca/SymmetricModesTest.java:57:44:57:62 | PaddingAlgorithm | +| jca/SymmetricModesTest.java:58:39:58:49 | Key | +| jca/SymmetricModesTest.java:59:29:59:50 | KeyOperationOutput | +| jca/SymmetricModesTest.java:59:29:59:50 | WrapOperation | +| jca/SymmetricModesTest.java:59:41:59:49 | Message | +| jca/SymmetricModesTest.java:78:43:78:55 | Parameter | +| jca/SymmetricModesTest.java:78:58:78:73 | Parameter | +| jca/SymmetricModesTest.java:79:44:79:63 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:79:44:79:63 | ModeOfOperation | +| jca/SymmetricModesTest.java:79:44:79:63 | PaddingAlgorithm | +| jca/SymmetricModesTest.java:81:9:81:40 | RandomNumberGeneration | +| jca/SymmetricModesTest.java:81:38:81:39 | RandomNumberGeneration | +| jca/SymmetricModesTest.java:83:42:83:44 | Key | +| jca/SymmetricModesTest.java:83:47:83:52 | Nonce | +| jca/SymmetricModesTest.java:84:29:84:53 | EncryptOperation | +| jca/SymmetricModesTest.java:84:29:84:53 | KeyOperationOutput | +| jca/SymmetricModesTest.java:84:44:84:52 | Message | +| jca/SymmetricModesTest.java:104:45:104:57 | Parameter | +| jca/SymmetricModesTest.java:104:60:104:75 | Parameter | +| jca/SymmetricModesTest.java:105:44:105:63 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:105:44:105:63 | ModeOfOperation | +| jca/SymmetricModesTest.java:105:44:105:63 | PaddingAlgorithm | +| jca/SymmetricModesTest.java:109:42:109:44 | Key | +| jca/SymmetricModesTest.java:109:47:109:52 | Nonce | +| jca/SymmetricModesTest.java:110:29:110:53 | EncryptOperation | +| jca/SymmetricModesTest.java:110:29:110:53 | KeyOperationOutput | +| jca/SymmetricModesTest.java:110:44:110:52 | Message | +| jca/SymmetricModesTest.java:127:52:127:56 | KeyOperationAlgorithm | +| jca/SymmetricModesTest.java:128:17:128:19 | Constant | +| jca/SymmetricModesTest.java:129:16:129:31 | Key | +| jca/SymmetricModesTest.java:129:16:129:31 | KeyGeneration | +| jca/UniversalFlowTest.java:19:28:19:32 | KeyOperationAlgorithm | +| jca/UniversalFlowTest.java:26:21:26:23 | Constant | +| jca/UniversalFlowTest.java:27:25:27:44 | Key | +| jca/UniversalFlowTest.java:27:25:27:44 | KeyGeneration | +| jca/UniversalFlowTest.java:28:29:28:47 | KeyOperationAlgorithm | +| jca/UniversalFlowTest.java:28:29:28:47 | ModeOfOperation | +| jca/UniversalFlowTest.java:28:29:28:47 | PaddingAlgorithm | +| jca/UniversalFlowTest.java:31:9:31:40 | RandomNumberGeneration | +| jca/UniversalFlowTest.java:31:38:31:39 | RandomNumberGeneration | +| jca/UniversalFlowTest.java:33:42:33:44 | Key | +| jca/UniversalFlowTest.java:33:47:33:53 | Nonce | +| jca/UniversalFlowTest.java:34:32:34:74 | EncryptOperation | +| jca/UniversalFlowTest.java:34:32:34:74 | KeyOperationOutput | +| jca/UniversalFlowTest.java:34:47:34:62 | Constant | +| jca/UniversalFlowTest.java:34:47:34:73 | Message | +| jca/UniversalFlowTest.java:46:20:46:24 | KeyOperationAlgorithm | diff --git a/java/ql/test/experimental/library-tests/quantum/nodes.ql b/java/ql/test/experimental/library-tests/quantum/nodes.ql new file mode 100644 index 000000000000..e080ce7297ac --- /dev/null +++ b/java/ql/test/experimental/library-tests/quantum/nodes.ql @@ -0,0 +1,5 @@ +import java +import experimental.quantum.Language + +from Crypto::NodeBase n +select n diff --git a/shared/quantum/codeql/quantum/experimental/Model.qll b/shared/quantum/codeql/quantum/experimental/Model.qll index a09b96cd550e..5ee0d1eb2982 100644 --- a/shared/quantum/codeql/quantum/experimental/Model.qll +++ b/shared/quantum/codeql/quantum/experimental/Model.qll @@ -1597,8 +1597,8 @@ module CryptographyBase Input> { final class MacOperationNode extends SignatureOrMacOperationNode { MacOperationNode() { this.getKeyOperationSubtype() = TMacMode() and - // If the type could be a mac, then we will not consider it a mac operation exclusively. - not exists(KeyOperationSubtype t | t = this.getKeyOperationSubtype() and t = TMacMode()) + // If the type could be a signature, then we will not consider it a mac operation exclusively. + not exists(KeyOperationSubtype t | t = this.getKeyOperationSubtype() and t = TSignMode()) } final override string getInternalType() { result = "MACOperation" } diff --git a/shared/quantum/codeql/quantum/experimental/Standardization.qll b/shared/quantum/codeql/quantum/experimental/Standardization.qll index 929c92aefff1..c713865f9aca 100644 --- a/shared/quantum/codeql/quantum/experimental/Standardization.qll +++ b/shared/quantum/codeql/quantum/experimental/Standardization.qll @@ -16,7 +16,7 @@ module Types { TSignature(TSignatureAlgorithmType t) or TMac(TMacAlgorithmType t) or TKeyEncapsulation(TKemAlgorithmType t) or - TUnknownKeyOperationAlgorithmType() + TOtherKeyOperationAlgorithmType() // Parameterized algorithm types newtype TSymmetricCipherType = @@ -49,6 +49,7 @@ module Types { DSA() or ECDSA() or EDDSA() or // e.g., ED25519 or ED448 + HSS_LMS() or // Leighton-Micali Signature OtherSignatureAlgorithmType() newtype TKemAlgorithmType = @@ -64,7 +65,7 @@ module Types { newtype TCipherStructureType = Block() or Stream() or - UnknownCipherStructureType() + OtherCipherStructureType() class CipherStructureType extends TCipherStructureType { string toString() { @@ -72,7 +73,7 @@ module Types { or result = "Stream" and this = Stream() or - result = "Unknown" and this = UnknownCipherStructureType() + result = "Unknown" and this = OtherCipherStructureType() } } @@ -119,7 +120,7 @@ module Types { or type = OtherSymmetricCipherType() and name = "UnknownSymmetricCipher" and - s = UnknownCipherStructureType() + s = OtherCipherStructureType() } class AlgorithmType extends TAlgorithm { @@ -157,7 +158,7 @@ module Types { this = TMac(OtherMacAlgorithmType()) and result = "UnknownMac" or // Unknown - this = TUnknownKeyOperationAlgorithmType() and result = "Unknown" + this = TOtherKeyOperationAlgorithmType() and result = "Unknown" } int getImplicitKeySize() {