We can get it from server module but we don't want mutual dependency. So
get it from config and keystore directly

@return String TLS server certificate finger print
498305
private String getServerTlsFingerPrint() {
        String fingerPrint = null;
        Map<String, Object> serverConfig = Config.getInstance().getJsonMapConfigNoCache("server");
        Map<String, Object> secretConfig = Config.getInstance().getJsonMapConfigNoCache("secret");
        // load keystore here based on server config and secret config
        String keystoreName = (String)serverConfig.get("keystoreName");
        String serverKeystorePass = (String)secretConfig.get("serverKeystorePass");
        if(keystoreName != null) {
            try (InputStream stream = Config.getInstance().getInputStreamFromFile(keystoreName)) {
                KeyStore loadedKeystore = KeyStore.getInstance("JKS");
                loadedKeystore.load(stream, serverKeystorePass.toCharArray());
                X509Certificate cert = (X509Certificate)loadedKeystore.getCertificate("server");
                if(cert != null) {
                    fingerPrint = FingerPrintUtil.getCertFingerPrint(cert);
                } else {
                    logger.error("Unable to find the certificate with alias name as server in the keystore");
                }
            } catch (Exception e) {
                logger.error("Unable to load server keystore ", e);
            }
        }
        return fingerPrint;
    }
1365965
public function getServerSignature()
    {

        // try to load the OS identifier
        list($os, ) = sscanf(strtolower(php_uname('s')), '%s %s');

        // check if we've a file with the actual version number
        if (file_exists($filename = $this->getConfDir('/.release-version'))) {
            $version = file_get_contents($filename);
        } else {
            $version = 'dev-' . gethostname();
        }

        // prepare and return the server signature
        return sprintf('appserver/%s (%s) PHP/%s', $version, $os, PHP_VERSION);
    }
1247067
public static function GetClientIpServer() {
        $ipaddress = '';
        if ($_SERVER['HTTP_CLIENT_IP'])
            $ipaddress = $_SERVER['HTTP_CLIENT_IP'];
        else if ($_SERVER['HTTP_X_FORWARDED_FOR'])
            $ipaddress = $_SERVER['HTTP_X_FORWARDED_FOR'];
        else if ($_SERVER['HTTP_X_FORWARDED'])
            $ipaddress = $_SERVER['HTTP_X_FORWARDED'];
        else if ($_SERVER['HTTP_FORWARDED_FOR'])
            $ipaddress = $_SERVER['HTTP_FORWARDED_FOR'];
        else if ($_SERVER['HTTP_FORWARDED'])
            $ipaddress = $_SERVER['HTTP_FORWARDED'];
        else if ($_SERVER['REMOTE_ADDR'])
            $ipaddress = $_SERVER['REMOTE_ADDR'];
        else
            $ipaddress = 'UNKNOWN';

        return $ipaddress;
    }
214202
public function getIsSecureConnection()
    {
        return isset($this->swooleRequest->server['HTTPS']) && (strcasecmp($this->swooleRequest->server['HTTPS'], 'on') === 0 || $_SERVER['HTTPS'] == 1)
            || isset($this->swooleRequest->server['HTTP_X_FORWARDED_PROTO']) && strcasecmp($this->swooleRequest->server['HTTP_X_FORWARDED_PROTO'], 'https') === 0;
    }
833632
public function getRsaPrivateKey()
    {
        if ($this->rsaPrivateKey) {
            return $this->rsaPrivateKey;
        }

        if (!file_exists($this->rsaPrivateKeyFile)) {
            throw new CredentialsException('Could not read the private key file.');
        }

        $this->rsaPrivateKey = openssl_pkey_get_private(file_get_contents($this->rsaPrivateKeyFile));

        if (!$this->rsaPrivateKey) {
            throw new CredentialsException('Cannot access private key for signing');
        }

        return $this->rsaPrivateKey;
    }
911271
private static function getLooseIP(): string
    {
        return md5(
            static::$tokenUseLooseIP && isset($_SERVER['REMOTE_ADDR'])
                ? \long2ip(\ip2long($_SERVER['REMOTE_ADDR']) & \ip2long('255.255.0.0'))
                : ''
        );
    }
1278609
public function getRequestSignature()
    {
        if (empty($this->requestSignature)) {

            $string = $this->getApiId()
                . $this->getTimeStamp()
                . $this->getNonce()
                . $this->getDataString();

            $this->requestSignature = hash_hmac('sha1', $string, $this->getService()->getApiSecret());
        }

        return $this->requestSignature;
    }
1341695
public static String getSignCertId() {
		try {
			Enumeration<String> aliasenum = keyStore.aliases();
			String keyAlias = null;
			if (aliasenum.hasMoreElements()) {
				keyAlias = aliasenum.nextElement();
			}
			X509Certificate cert = (X509Certificate) keyStore
					.getCertificate(keyAlias);
			return cert.getSerialNumber().toString();
		} catch (Exception e) {
			e.printStackTrace();
			LogUtil.writeErrorLog("getSignCertId Error", e);
			return null;
		}
	}
96488
private String getCertificateFingerPrint(String mdAlg) {
        String fingerPrint = "";
        try {
            byte[] encCertInfo = getEncoded();
            MessageDigest md = MessageDigest.getInstance(mdAlg);
            byte[] digest = md.digest(encCertInfo);
            StringBuffer buf = new StringBuffer();
            for (int i = 0; i < digest.length; i++) {
                byte2hex(digest[i], buf);
            }
            fingerPrint = buf.toString();
        } catch (NoSuchAlgorithmException | CertificateEncodingException e) {
            // ignored
        }
        return fingerPrint;
    }
786103
protected function fetchCertificate()
    {
        $metadata = file_get_contents($this->getBaseUrl() . $this->getAdminSpMetadataFile());
        $deserializationContext = new DeserializationContext();
        $deserializationContext->getDocument()->loadXML($metadata);

        $ed = new EntityDescriptor();

        $ed->deserialize($deserializationContext->getDocument(), $deserializationContext);

        $certificate = $ed->getFirstSpSsoDescriptor()->getFirstKeyDescriptor(KeyDescriptor::USE_ENCRYPTION)
            ? $ed->getFirstSpSsoDescriptor()->getFirstKeyDescriptor(KeyDescriptor::USE_ENCRYPTION)
                ->getCertificate()
                ->toPem()
            : $ed->getFirstSpSsoDescriptor()->getFirstKeyDescriptor(KeyDescriptor::USE_SIGNING)
                ->getCertificate()
                ->toPem();

        return $certificate;
    }
308301
public function getPublicMasterKey()
    {
        if (!$this->publicMasterKey) {
            $masterKey = $this->getMasterKey();
            $publicKeyDetails = openssl_pkey_get_details($masterKey);
            $this->publicMasterKey = $publicKeyDetails['key'];
        }
        return $this->publicMasterKey;
    }
1044446
public function getApplePayProcessingCertificatePassword() {
        $pass = $this->scopeConfig->getValue(
            'payment/checkout_com_applepay/processing_certificate_password',
            ScopeInterface::SCOPE_STORE
        );
        trim($pass);
        return ($pass) ? $pass : ''; 
    }
327842
public function getIsSecureConnection()
    {
        $https = $this->getServerParam('HTTPS');
        if ($https !== null && (strcasecmp($https, 'on') === 0 || $https == 1)) {
            return true;
        }
        foreach ($this->secureProtocolHeaders as $header => $values) {
            if ($this->hasHeader($header)) {
                foreach ($values as $value) {
                    if (strcasecmp($this->getHeaderLine($header), $value) === 0) {
                        return true;
                    }
                }
            }
        }

        return false;
    }
435625
public static function getProtocolInformation()
    {
        if (isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] == 443) {
            return 'SERVER_PORT=443';
        }

        if (isset($_SERVER['HTTP_X_FORWARDED_PROTO']) && strtolower($_SERVER['HTTP_X_FORWARDED_PROTO']) == 'https') {
            return 'X-Forwarded-Proto';
        }

        if (isset($_SERVER['HTTP_X_FORWARDED_SCHEME']) && strtolower($_SERVER['HTTP_X_FORWARDED_SCHEME']) == 'https') {
            return 'X-Forwarded-Scheme';
        }

        if (isset($_SERVER['HTTP_X_URL_SCHEME']) && strtolower($_SERVER['HTTP_X_URL_SCHEME']) == 'https') {
            return 'X-Url-Scheme';
        }

        return null;
    }
131206
public String getFingerprint() {
        RSAPublicKey key = InstanceIdentityProvider.RSA.getPublicKey();
        if (key == null) {
            return null;
        }
        // TODO replace with org.jenkinsci.remoting.util.KeyUtils once JENKINS-36871 changes are merged
        try {
            MessageDigest digest = MessageDigest.getInstance("MD5");
            digest.reset();
            byte[] bytes = digest.digest(key.getEncoded());
            StringBuilder result = new StringBuilder(Math.max(0, bytes.length * 3 - 1));
            for (int i = 0; i < bytes.length; i++) {
                if (i > 0) {
                    result.append(':');
                }
                int b = bytes[i] & 0xFF;
                result.append(Character.forDigit((b>>4)&0x0f, 16)).append(Character.forDigit(b&0xf, 16));
            }
            return result.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException("JLS mandates MD5 support");
        }
    }
215415
public function ssl()
    {
        if (is_null($this->ssl)) {
            $this->ssl = app(Ssl::class);
        }

        return $this->ssl;
    }
640984
public function getEncryptionKey()
    {
        // initial key
        $securityKey = $this->securityKey;

        // append current session id
        $securityKey .= $this->httpSession()->getSessionId();

        // hash and return
        return hash('sha512', $securityKey);
    }