return the AuthorityKeyIdentifier, if any.

@returns AuthorityKeyIdentifier or null
(if no AuthorityKeyIdentifierExtension)
@throws IOException on error
552624
public KeyIdentifier getAuthKeyId() throws IOException {
        AuthorityKeyIdentifierExtension aki = getAuthKeyIdExtension();
        if (aki != null) {
            KeyIdentifier keyId = (KeyIdentifier)aki.get(
                    AuthorityKeyIdentifierExtension.KEY_ID);
            return keyId;
        } else {
            return null;
        }
    }
978696
public byte[] getPrivKeyBytes() {
        if (privKey == null) {
            return null;
        } else if (privKey instanceof BCECPrivateKey) {
            return bigIntegerToBytes(((BCECPrivateKey) privKey).getD(), 32);
        } else {
            return null;
        }
    }
1363286
public TypeSignature getTypeSignature() {
        if (typeSignatureStr == null) {
            return null;
        }
        if (typeSignature == null) {
            try {
                typeSignature = TypeSignature.parse(typeSignatureStr, declaringClassName);
                typeSignature.setScanResult(scanResult);
            } catch (final ParseException e) {
                throw new IllegalArgumentException(e);
            }
        }
        return typeSignature;
    }
11146
public Identity identity() throws IOException {
        final Iterator<String> headers =
            new RqHeaders.Base(this).header(this.header).iterator();
        final Identity user;
        if (headers.hasNext()) {
            user = new CcPlain().decode(
                new Utf8String(headers.next()).asBytes()
            );
        } else {
            user = Identity.ANONYMOUS;
        }
        return user;
    }
1053575
public KeyPair getKeyPair() throws GeneralSecurityException, IOException {
        if (privateKeyAsSeed == null) {
            throw new IllegalStateException("Public-only NKey");
        }

        DecodedSeed decoded = decodeSeed(privateKeyAsSeed);
        byte[] seedBytes = new byte[ED25519_SEED_SIZE];
        byte[] pubBytes = new byte[ED25519_PUBLIC_KEYSIZE];

        System.arraycopy(decoded.bytes, 0, seedBytes, 0, seedBytes.length);
        System.arraycopy(decoded.bytes, seedBytes.length, pubBytes, 0, pubBytes.length);

        EdDSAPrivateKeySpec privKeySpec = new EdDSAPrivateKeySpec(seedBytes, NKey.ed25519);
        EdDSAPrivateKey privKey = new EdDSAPrivateKey(privKeySpec);
        EdDSAPublicKeySpec pubKeySpec = new EdDSAPublicKeySpec(pubBytes, NKey.ed25519);
        EdDSAPublicKey pubKey = new EdDSAPublicKey(pubKeySpec);

        return new KeyPair(pubKey, privKey);
    }
123778
protected String getSigningKey() {
        if (extendedMetadata != null && extendedMetadata.getSigningKey() != null) {
            return extendedMetadata.getSigningKey();
        } else {
            return keyManager.getDefaultCredentialName();
        }
    }
1200472
@Override
	public ORID getIdentity(final Object iPojo) {
		checkOpeness();
		final ODocument record = getRecordByUserObject(iPojo, false);
		if (record != null)
			return record.getIdentity();
		return OObjectSerializerHelper.getObjectID(this, iPojo);
	}
300537
public Identity getIdentity()
    {
        if(identity == null)
        {
            identity = tx.getBroker().serviceIdentity().buildIdentity(obj);
        }
        return identity;
    }
297908
public KeyIdentifier keyIdentifier() {
        if (key() == null || key().kid() == null || key().kid().length() == 0) {
            return null;
        }
        return new KeyIdentifier(key().kid());
    }
797707
public PGPSecretKeyRing getSigningKeyRing() throws IOException, PGPException {
        PGPSecretKeyRingCollection secretKeyRings = getSecretKeys();
        if (secretKeyRings == null) {
            return null;
        }

        PGPSecretKeyRing signingKeyRing = null;
        for (PGPSecretKeyRing ring : secretKeyRings) {
            if (signingKeyRing == null) {
                signingKeyRing = ring;
                continue;
            }

            if (ring.getPublicKey().getCreationTime().after(signingKeyRing.getPublicKey().getCreationTime())) {
                signingKeyRing = ring;
            }
        }

        return signingKeyRing;
    }
890909
public static AlgorithmIdentifier getSignerAlgoritmIdentifier(Signer signer)
    {
        if (signer instanceof ContentSigner) {
            return ((ContentSigner) signer).getAlgorithmIdentifier();
        } else {
            return AlgorithmIdentifier.getInstance(signer.getEncoded());
        }
    }
1369300
public String getIssueKey() {
        Issue issue = getAnnotation(Issue.class);
        return issue == null ? null : issue.value();
    }
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;
		}
	}
1183702
@Override
    public Optional<Identification> getIdentification(Identifiable identifiable) {
        if(!registered.containsKey(identifiable.getID())) {
            return Optional.empty();
        }
        AddOnModel registered = addOnInformationManager.getAddonModel(this.registered.get(identifiable.getID()));
        AddOnModel requested = addOnInformationManager.getAddonModel(identifiable);
        if (!(registered == requested)) {
            return Optional.empty();
        }
        return Optional.of(IdentificationImpl.createIdentification(identifiable, true));
    }
319625
public com.google.api.Authentication getAuthentication() {
    return authentication_ == null ? com.google.api.Authentication.getDefaultInstance() : authentication_;
  }
1041148
public BasicAuthAuthenticator getBasicAuthAuthenticator() {
        try {
            return createBasicAuthenticator();
        } catch (RegistryException e) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "RegistryException while trying to create BasicAuthAuthenticator", e);
            }
        }
        return null;
    }
1172510
private String getLogRequestIdentifier() {
        if (logIdentifier == null) {
            logIdentifier = String.format("%s-%s %s %s", Integer.toHexString(hashCode()),
                    numberOfRetries, connection.getRequestMethod(), connection.getURL());
        }
        return logIdentifier;
    }