Does the current session fingerprint match a parameter

When no parameter is given we use GET->s as default parameter

@param string 		$fingerprint
@return string
546947
public function valid_fingerprint( $fingerprint = null )
	{
		if ( is_null( $fingerprint ) )
		{
			$fingerprint = \CCIn::get( \ClanCats::$config->get( 'session.default_fingerprint_parameter' ), false );
		}
		
		return $this->fingerprint === $fingerprint;
	}
775124
public function generateFingerprint()
    {
        // Assume empty fingerprint
        $fingerprint = '';

        // Get arguments
        $arguments = func_get_args();

        foreach ($arguments as $argument) {
            $fingerprint .= serialize($argument);
        }

        return $fingerprint;
    }
368246
protected final String getFingerprint(Description description) {
        return TestResultDataUtils.getFingerprint(description.getTestClass(), description.getMethodName());
    }
1320019
public static String fingerprint(Class cl, Method m) {
		return fingerprint(cl, m.getName());
	}
424371
public function getFingerprint(string $algorithm = 'SHA1'): Hash {
        $value = openssl_x509_fingerprint(
            $this->getHandle(),
            $algorithm,
            TRUE
        );
        if(!$value) {
            throw new RuntimeException(OpenSSL::getLastError());
        }
        $hash = new Hash($algorithm);
        $hash->setValue($value);
        return $hash;
    }
190110
protected function resolveRequestSignature($request)
    {
        $route = $request->route()[1];

        if (! $route) {
            throw new RuntimeException('Unable to generate fingerprint. Route unavailable.');
        }

        return \sha1(
            \implode('|', $route['version']).'|'.$request->fullUrl().'|'.$request->ip()
        );
    }
201979
private boolean matchesFingerprint(byte[] buffer, Pattern fingerprint)
   {
      return fingerprint.matcher(m_charset == null ? new String(buffer) : new String(buffer, m_charset)).matches();
   }
184859
public Fingerprint getLogicalFingerprint (String retina_name, String logical_name) throws ApiException {
        // verify required params are set
        if(retina_name == null || logical_name == null ) {
             throw new ApiException(400, "missing required params");
        }
        // create path and map variables
        String path = "/fingerprints/byName".replaceAll("\\{format\\}","json");

        // query params
        Map<String, String> queryParams = new HashMap<String, String>();
        Map<String, String> headerParams = new HashMap<String, String>();

        if(!"null".equals(String.valueOf(retina_name)))
            queryParams.put("retina_name", String.valueOf(retina_name));
        if(!"null".equals(String.valueOf(logical_name)))
            queryParams.put("logical_name", String.valueOf(logical_name));
        String contentType = "application/json";

        try {
            Object response = apiInvoker.invokeAPI(basePath, path, "GET", queryParams
                , null, headerParams, contentType);
            if(response != null) {
                if (response instanceof String) {
                        @SuppressWarnings("unchecked")
                        Fingerprint result = (Fingerprint) ApiInvoker.deserialize( (String) response, ""
                                , Fingerprint.class, null);return result;
                }
                else if (response instanceof java.io.ByteArrayInputStream) {
                        @SuppressWarnings("unchecked")
                        Fingerprint result =    (Fingerprint) response;return result;
                }
                
            }
            else {
                return null;
            }
        } catch (ApiException ex) {
            if(ex.getCode() == 404) {
            	return null;
            }
            else {
                throw ex;
            }
        }
        return null;}
1040374
@StaplerDispatchable
    public Object getFingerprint( String md5sum ) throws IOException {
        Fingerprint r = fingerprintMap.get(md5sum);
        if(r==null)     return new NoFingerprintMatch(md5sum);
        else            return r;
    }
544181
public function fingerprint()
    {
        if (! $route = $this->route()) {
            throw new RuntimeException('Unable to generate fingerprint. Route unavailable.');
        }

        return sha1(implode('|', array_merge(
            $route->methods(),
            [$route->getDomain(), $route->uri(), $this->ip()]
        )));
    }
976120
public function setFingerprint($fingerprint = null)
    {
        if (isset($fingerprint)) {
            $this->fingerprint = $fingerprint;
        } else {
            $this->fingerprint = 'assely-'.Str::random();
        }

        return $this;
    }
1279446
public function destroyKeypair($fingerprint)
    {
        if ($fingerprint === null || !isset($this->keys[$fingerprint])) {
            throw new InvalidKeyPairIdException('Invalid keypair fingerprint given', 1231438863);
        }

        unset($this->keys[$fingerprint]);
        $this->saveKeysOnShutdown = true;
    }
609099
public static function calculateX509Fingerprint($x509cert, $alg = 'sha1')
    {
        assert('is_string($x509cert)');

        $arCert = explode("\n", $x509cert);
        $data = '';
        $inData = false;

        foreach ($arCert as $curData) {
            if (! $inData) {
                if (strncmp($curData, '-----BEGIN CERTIFICATE', 22) == 0) {
                    $inData = true;
                } elseif ((strncmp($curData, '-----BEGIN PUBLIC KEY', 21) == 0) || (strncmp($curData, '-----BEGIN RSA PRIVATE KEY', 26) == 0)) {
                    /* This isn't an X509 certificate. */
                    return null;
                }
            } else {
                if (strncmp($curData, '-----END CERTIFICATE', 20) == 0) {
                    break;
                }
                $data .= trim($curData);
            }
        }

        if (empty($data)) {
            return null;
        }

        $decodedData = base64_decode($data);

        switch ($alg) {
            case 'sha512':
            case 'sha384':
            case 'sha256':
                $fingerprint = hash($alg, $decodedData, false);
                break;
            case 'sha1':
            default:
                $fingerprint = strtolower(sha1($decodedData));
                break;
        }
        return $fingerprint;
    }
1080893
protected static function fingerprint($blockSize = Cuid::NORMAL_BLOCK)
    {
        // Generate process id based hash
        $pid = Cuid::pad(
            base_convert(
                getmypid(),
                Cuid::DECIMAL,
                Cuid::BASE36
            ),
            Cuid::NORMAL_BLOCK / 2
        );

        // Generate hostname based hash
        $hostname = Cuid::pad(
            base_convert(
                array_reduce(
                    str_split(gethostname()),
                    function ($carry, $char) {
                        return $carry + ord($char);
                    },
                    strlen(gethostname()) + Cuid::BASE36
                ),
                Cuid::DECIMAL,
                Cuid::BASE36
            ),
            2
        );

        // Return small or normal block of hash
        if ($blockSize == Cuid::SMALL_BLOCK) {
            return substr($pid, 0, 1) . substr($hostname, -1);
        }

        return $pid . $hostname;
    }
447287
def fingerprint_target(self, target):
    """"""
    fingerprint = self.compute_fingerprint(target)
    if fingerprint:
      return '{fingerprint}-{name}'.format(fingerprint=fingerprint, name=type(self).__name__)
    else:
      return None
451772
public function signatureParameters( $subClass = null )
	{
		$action = $this->getAction();

		if ( is_string( $action['uses'] ) )
		{
			list( $class, $method ) = explode( '@', $action['uses'] );
			$parameters = ( new ReflectionMethod( $class, $method ) )->getParameters();
		}
		else
			$parameters = ( new ReflectionFunction( $action['uses'] ) )->getParameters();

		return is_null( $subClass ) ? $parameters : array_filter( $parameters, function ( $p ) use ( $subClass )
		{
			return $p->getClass() && $p->getClass()->isSubclassOf( $subClass );
		} );
	}
1091646
public byte[] getFingerprintFromFile(String fingerprintFile) {
        byte[] fingerprint = null;
        try {
            InputStream fis = new FileInputStream(fingerprintFile);
            fingerprint = getFingerprintFromInputStream(fis);
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return fingerprint;
    }