<code>.google.privacy.dlp.v2.CryptoReplaceFfxFpeConfig crypto_replace_ffx_fpe_config = 4;
</code>
989
public com.google.privacy.dlp.v2.CryptoReplaceFfxFpeConfigOrBuilder
      getCryptoReplaceFfxFpeConfigOrBuilder() {
    if (transformationCase_ == 4) {
      return (com.google.privacy.dlp.v2.CryptoReplaceFfxFpeConfig) transformation_;
    }
    return com.google.privacy.dlp.v2.CryptoReplaceFfxFpeConfig.getDefaultInstance();
  }
880200
public com.google.privacy.dlp.v2.CryptoDeterministicConfigOrBuilder
      getCryptoDeterministicConfigOrBuilder() {
    if (transformationCase_ == 12) {
      return (com.google.privacy.dlp.v2.CryptoDeterministicConfig) transformation_;
    }
    return com.google.privacy.dlp.v2.CryptoDeterministicConfig.getDefaultInstance();
  }
91393
function _setupInlineCrypt()
    {
        $lambda_functions =& self::_getLambdaFunctions();

        // We create max. 10 hi-optimized code for memory reason. Means: For each $key one ultra fast inline-crypt function.
        // (Currently, for Blowfish, one generated $lambda_function cost on php5.5@32bit ~100kb unfreeable mem and ~180kb on php5.5@64bit)
        // After that, we'll still create very fast optimized code but not the hi-ultimative code, for each $mode one.
        $gen_hi_opt_code = (bool)(count($lambda_functions) < 10);

        // Generation of a unique hash for our generated code
        $code_hash = "Crypt_Blowfish, {$this->mode}";
        if ($gen_hi_opt_code) {
            $code_hash = str_pad($code_hash, 32) . $this->_hashInlineCryptFunction($this->key);
        }

        $safeint = $this->safe_intval_inline();

        if (!isset($lambda_functions[$code_hash])) {
            switch (true) {
                case $gen_hi_opt_code:
                    $p = $this->bctx['p'];
                    $init_crypt = '
                        static $sb_0, $sb_1, $sb_2, $sb_3;
                        if (!$sb_0) {
                            $sb_0 = $self->bctx["sb"][0];
                            $sb_1 = $self->bctx["sb"][1];
                            $sb_2 = $self->bctx["sb"][2];
                            $sb_3 = $self->bctx["sb"][3];
                        }
                    ';
                    break;
                default:
                    $p   = array();
                    for ($i = 0; $i < 18; ++$i) {
                        $p[] = '$p_' . $i;
                    }
                    $init_crypt = '
                        list($sb_0, $sb_1, $sb_2, $sb_3) = $self->bctx["sb"];
                        list(' . implode(',', $p) . ') = $self->bctx["p"];

                    ';
            }

            // Generating encrypt code:
            $encrypt_block = '
                $in = unpack("N*", $in);
                $l = $in[1];
                $r = $in[2];
            ';
            for ($i = 0; $i < 16; $i+= 2) {
                $encrypt_block.= '
                    $l^= ' . $p[$i] . ';
                    $r^= ' . sprintf($safeint, '(' . sprintf($safeint, '$sb_0[$l >> 24 & 0xff] + $sb_1[$l >> 16 & 0xff]') . ' ^
                          $sb_2[$l >>  8 & 0xff]) +
                          $sb_3[$l       & 0xff]') . ';

                    $r^= ' . $p[$i + 1] . ';
                    $l^= ' . sprintf($safeint, '(' . sprintf($safeint, '$sb_0[$r >> 24 & 0xff] + $sb_1[$r >> 16 & 0xff]') . '  ^
                          $sb_2[$r >>  8 & 0xff]) +
                          $sb_3[$r       & 0xff]') . ';
                ';
            }
            $encrypt_block.= '
                $in = pack("N*",
                    $r ^ ' . $p[17] . ',
                    $l ^ ' . $p[16] . '
                );
            ';

            // Generating decrypt code:
            $decrypt_block = '
                $in = unpack("N*", $in);
                $l = $in[1];
                $r = $in[2];
            ';

            for ($i = 17; $i > 2; $i-= 2) {
                $decrypt_block.= '
                    $l^= ' . $p[$i] . ';
                    $r^= ' . sprintf($safeint, '(' . sprintf($safeint, '$sb_0[$l >> 24 & 0xff] + $sb_1[$l >> 16 & 0xff]') . ' ^
                          $sb_2[$l >>  8 & 0xff]) +
                          $sb_3[$l       & 0xff]') . ';

                    $r^= ' . $p[$i - 1] . ';
                    $l^= ' . sprintf($safeint, '(' . sprintf($safeint, '$sb_0[$r >> 24 & 0xff] + $sb_1[$r >> 16 & 0xff]') . ' ^
                          $sb_2[$r >>  8 & 0xff]) +
                          $sb_3[$r       & 0xff]') . ';
                ';
            }

            $decrypt_block.= '
                $in = pack("N*",
                    $r ^ ' . $p[0] . ',
                    $l ^ ' . $p[1] . '
                );
            ';

            $lambda_functions[$code_hash] = $this->_createInlineCryptFunction(
                array(
                   'init_crypt'    => $init_crypt,
                   'init_encrypt'  => '',
                   'init_decrypt'  => '',
                   'encrypt_block' => $encrypt_block,
                   'decrypt_block' => $decrypt_block
                )
            );
        }
        $this->inline_crypt = $lambda_functions[$code_hash];
    }
1166775
@Benchmark
    @OperationsPerInvocation(20)
    public void benchmarkJdkProxy(Blackhole blackHole) {
        blackHole.consume(jdkProxyInstance.method(booleanValue));
        blackHole.consume(jdkProxyInstance.method(byteValue));
        blackHole.consume(jdkProxyInstance.method(shortValue));
        blackHole.consume(jdkProxyInstance.method(intValue));
        blackHole.consume(jdkProxyInstance.method(charValue));
        blackHole.consume(jdkProxyInstance.method(intValue));
        blackHole.consume(jdkProxyInstance.method(longValue));
        blackHole.consume(jdkProxyInstance.method(floatValue));
        blackHole.consume(jdkProxyInstance.method(doubleValue));
        blackHole.consume(jdkProxyInstance.method(stringValue));
        blackHole.consume(jdkProxyInstance.method(booleanValue, booleanValue, booleanValue));
        blackHole.consume(jdkProxyInstance.method(byteValue, byteValue, byteValue));
        blackHole.consume(jdkProxyInstance.method(shortValue, shortValue, shortValue));
        blackHole.consume(jdkProxyInstance.method(intValue, intValue, intValue));
        blackHole.consume(jdkProxyInstance.method(charValue, charValue, charValue));
        blackHole.consume(jdkProxyInstance.method(intValue, intValue, intValue));
        blackHole.consume(jdkProxyInstance.method(longValue, longValue, longValue));
        blackHole.consume(jdkProxyInstance.method(floatValue, floatValue, floatValue));
        blackHole.consume(jdkProxyInstance.method(doubleValue, doubleValue, doubleValue));
        blackHole.consume(jdkProxyInstance.method(stringValue, stringValue, stringValue));
    }
1098264
public com.google.privacy.dlp.v2.UnwrappedCryptoKeyOrBuilder getUnwrappedOrBuilder() {
    if (sourceCase_ == 2) {
      return (com.google.privacy.dlp.v2.UnwrappedCryptoKey) source_;
    }
    return com.google.privacy.dlp.v2.UnwrappedCryptoKey.getDefaultInstance();
  }
554160
static final synchronized CryptoSuiteFactory getDefault() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {

        if (null == theFACTORY) {

            String cf = config.getDefaultCryptoSuiteFactory();
            if (null == cf || cf.isEmpty() || cf.equals(HLSDKJCryptoSuiteFactory.class.getName())) { // Use this class as the factory.

                theFACTORY = HLSDKJCryptoSuiteFactory.instance();

            } else {

                // Invoke static method instance on factory class specified by config properties.
                // In this case this class will no longer be used as the factory.

                Class<?> aClass = Class.forName(cf);

                Method method = aClass.getMethod("instance");
                Object theFACTORYObject = method.invoke(null);
                if (null == theFACTORYObject) {
                    throw new InstantiationException(String.format("Class specified by %s has instance method returning null.  Expected object implementing CryptoSuiteFactory interface.", cf));
                }

                if (!(theFACTORYObject instanceof CryptoSuiteFactory)) {

                    throw new InstantiationException(String.format("Class specified by %s has instance method returning a class %s which does not implement interface CryptoSuiteFactory ",
                            cf, theFACTORYObject.getClass().getName()));

                }

                theFACTORY = (CryptoSuiteFactory) theFACTORYObject;

            }
        }

        return theFACTORY;
    }
845918
function Crypt_RC4()
    {
        if ( !defined('CRYPT_RC4_MODE') ) {
            switch (true) {
                case extension_loaded('mcrypt') && (defined('MCRYPT_ARCFOUR') || defined('MCRYPT_RC4')) && in_array('arcfour', mcrypt_list_algorithms()):
                    define('CRYPT_RC4_MODE', CRYPT_RC4_MODE_MCRYPT);
                    break;
                default:
                    define('CRYPT_RC4_MODE', CRYPT_RC4_MODE_INTERNAL);
            }
        }

        switch ( CRYPT_RC4_MODE ) {
            case CRYPT_RC4_MODE_MCRYPT:
                switch (true) {
                    case defined('MCRYPT_ARCFOUR'):
                        $this->mode = MCRYPT_ARCFOUR;
                        break;
                    case defined('MCRYPT_RC4');
                        $this->mode = MCRYPT_RC4;
                }
        }
    }
346208
public com.google.privacy.dlp.v2.DateShiftConfigOrBuilder getDateShiftConfigOrBuilder() {
    if (transformationCase_ == 11) {
      return (com.google.privacy.dlp.v2.DateShiftConfig) transformation_;
    }
    return com.google.privacy.dlp.v2.DateShiftConfig.getDefaultInstance();
  }
389669
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1784")
  @CanIgnoreReturnValue
  public static SslContextBuilder configure(SslContextBuilder builder, SslProvider provider) {
    switch (provider) {
      case JDK:
      {
        Provider jdkProvider = findJdkProvider();
        if (jdkProvider == null) {
          throw new IllegalArgumentException(
              "Could not find Jetty NPN/ALPN or Conscrypt as installed JDK providers");
        }
        return configure(builder, jdkProvider);
      }
      case OPENSSL:
      {
        ApplicationProtocolConfig apc;
        if (OpenSsl.isAlpnSupported()) {
          apc = NPN_AND_ALPN;
        } else {
          apc = NPN;
        }
        return builder
            .sslProvider(SslProvider.OPENSSL)
            .ciphers(Http2SecurityUtil.CIPHERS, SupportedCipherSuiteFilter.INSTANCE)
            .applicationProtocolConfig(apc);
      }
      default:
        throw new IllegalArgumentException("Unsupported provider: " + provider);
    }
  }
607975
public com.google.privacy.dlp.v2.PrivacyMetric.LDiversityConfigOrBuilder
      getLDiversityConfigOrBuilder() {
    if (typeCase_ == 4) {
      return (com.google.privacy.dlp.v2.PrivacyMetric.LDiversityConfig) type_;
    }
    return com.google.privacy.dlp.v2.PrivacyMetric.LDiversityConfig.getDefaultInstance();
  }
391121
private SecurityConfiguration getEffectiveSecurityConfiguration() {
        SecurityConfiguration effectiveConfig = configs.getService(cfgSystemDomain);
        if (effectiveConfig == null) {
            Tr.error(tc, "SECURITY_SERVICE_ERROR_BAD_DOMAIN", cfgSystemDomain, CFG_KEY_SYSTEM_DOMAIN);
            throw new IllegalArgumentException(Tr.formatMessage(tc, "SECURITY_SERVICE_ERROR_BAD_DOMAIN", cfgSystemDomain, CFG_KEY_SYSTEM_DOMAIN));
        }
        return effectiveConfig;
    }
555728
public com.google.privacy.dlp.v2.PrivacyMetric.DeltaPresenceEstimationConfigOrBuilder
      getDeltaPresenceEstimationConfigOrBuilder() {
    if (typeCase_ == 6) {
      return (com.google.privacy.dlp.v2.PrivacyMetric.DeltaPresenceEstimationConfig) type_;
    }
    return com.google.privacy.dlp.v2.PrivacyMetric.DeltaPresenceEstimationConfig
        .getDefaultInstance();
  }
840667
@FFDCIgnore({ NoSuchElementException.class })
    protected Map<String, String> getMpConfig(MpConfigProxyService service, ClassLoader cl, String propertyName,  Map<String, String> map) {
        try {
            String value = service.getConfigValue(cl, propertyName, String.class).trim();
            if (!value.isEmpty()) {
                map.put(propertyName, value);
            } else {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, propertyName + " is empty. Ignore it.");
                }
            }
        } catch (NoSuchElementException e) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, propertyName + " is not in mpConfig.");
            }
        }
        return map;
    }
451896
public com.google.privacy.dlp.v2.PrivacyMetric.NumericalStatsConfig getNumericalStatsConfig() {
    if (typeCase_ == 1) {
      return (com.google.privacy.dlp.v2.PrivacyMetric.NumericalStatsConfig) type_;
    }
    return com.google.privacy.dlp.v2.PrivacyMetric.NumericalStatsConfig.getDefaultInstance();
  }
401510
@Override
  public BigInteger computeClientEvidence(
      SRP6CryptoParams cryptoParams, SRP6ClientEvidenceContext ctx) {

    MessageDigest digest;
    try {
      digest = MessageDigest.getInstance(cryptoParams.H);
    } catch (NoSuchAlgorithmException e) {
      throw new RuntimeException("Could not locate requested algorithm", e);
    }
    digest.update(SrpHandler.bigIntegerToUnsignedByteArray(cryptoParams.N));
    byte[] hN = digest.digest();

    digest.update(SrpHandler.bigIntegerToUnsignedByteArray(cryptoParams.g));
    byte[] hg = digest.digest();

    byte[] hNhg = xor(hN, hg);

    digest.update(ctx.userID.getBytes(StandardCharsets.UTF_8));
    byte[] hu = digest.digest();

    digest.update(SrpHandler.bigIntegerToUnsignedByteArray(ctx.S));
    byte[] hS = digest.digest();

    digest.update(hNhg);
    digest.update(hu);
    digest.update(SrpHandler.bigIntegerToUnsignedByteArray(ctx.s));
    digest.update(SrpHandler.bigIntegerToUnsignedByteArray(ctx.A));
    digest.update(SrpHandler.bigIntegerToUnsignedByteArray(ctx.B));
    digest.update(hS);
    BigInteger ret = new BigInteger(1, digest.digest());
    return ret;
  }
952605
@FFDCIgnore(PrivilegedActionException.class)
    private String getConfigNameForRef(final String ref) {
        String name = null;
        if (ref != null) {
            final ConfigurationAdmin configAdmin = configAdminRef.getService();
            Configuration config;
            try {
                config = AccessController.doPrivileged(new PrivilegedExceptionAction<Configuration>() {
                    @Override
                    public Configuration run() throws IOException {
                        return configAdmin.getConfiguration(ref, configAdminRef.getReference().getBundle().getLocation());
                    }
                });
            } catch (PrivilegedActionException paex) {
                return null;
            }
            Dictionary<String, Object> props = config.getProperties();
            name = (String) props.get(KEY_NAME);
        }
        return name;
    }
1074721
@Override
  public String cipherSuite()
  {
    if (! (_s instanceof SSLSocket)) {
      return super.cipherSuite();
    }

    SSLSocket sslSocket = (SSLSocket) _s;
    
    SSLSession sslSession = sslSocket.getSession();
    
    if (sslSession != null) {
      return sslSession.getCipherSuite();
    }
    else {
      return null;
    }
  }