import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
private SignatureStatus verifySignatureForTrustedAuthority(DirectoryServer trustedAuthority, DirectorySignature signature) {
	final KeyCertificate certificate = trustedAuthority.getCertificateByFingerprint(signature.getSigningKeyDigest());
	if(certificate == null) {
		logger.fine("Missing certificate for signing key: "+ signature.getSigningKeyDigest());
		addRequiredCertificateForSignature(signature);
		return SignatureStatus.STATUS_NEED_CERTS;
	}
	if(certificate.isExpired()) {
		return SignatureStatus.STATUS_FAILED;
	}
	
	final TorPublicKey signingKey = certificate.getAuthoritySigningKey();
	final HexDigest d = (signature.useSha256()) ? signingHash256 : signingHash;
	if(!signingKey.verifySignature(signature.getSignature(), d)) {
		logger.warning("Signature failed on consensus for signing key: "+ signature.getSigningKeyDigest());
		return SignatureStatus.STATUS_FAILED;
	}
	return SignatureStatus.STATUS_VERIFIED;
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
boolean sendIntroduce(TorPublicKey permanentKey, byte[] publicKeyBytes, byte[] rendezvousCookie, Router rendezvousRouter) {
	final RelayCell introduceCell = introductionCircuit.createRelayCell(RelayCell.RELAY_COMMAND_INTRODUCE1, 0, introductionCircuit.getFinalCircuitNode());

	final byte[] payload = createIntroductionPayload(rendezvousRouter, publicKeyBytes, rendezvousCookie, permanentKey);
	final TorPublicKey serviceKey = introductionPoint.getServiceKey();
	introduceCell.putByteArray(serviceKey.getFingerprint().getRawBytes());
	introduceCell.putByteArray(payload);
	introductionCircuit.sendRelayCell(introduceCell);
	
	final RelayCell response = introductionCircuit.receiveRelayCell();
	if(response == null) {
		logger.fine("Timeout waiting for response to INTRODUCE1 cell");
		return false;
	} else if(response.getRelayCommand() != RelayCell.RELAY_COMMAND_INTRODUCE_ACK) {
		logger.info("Unexpected relay cell type received waiting for response to INTRODUCE1 cell: "+ response.getRelayCommand());
		return false;
	} else if(response.cellBytesRemaining() == 0) {
		return true;
	} else {
		logger.info("INTRODUCE_ACK indicates that introduction was not forwarded: "+ response.getByte());
		return false;
	} 
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
protected void verifyIdentityKey(PublicKey publicKey) throws ConnectionHandshakeException {
	if(!(publicKey instanceof RSAPublicKey)) {
		throw new ConnectionHandshakeException("Identity certificate public key is not an RSA key as expected");
	}
	final TorPublicKey identityKey = new TorPublicKey((RSAPublicKey)publicKey);
	final Router router = connection.getRouter();
	if((router instanceof BridgeRouter) && (router.getIdentityHash() == null)) {
		logger.info("Setting Bridge fingerprint from connection handshake for "+ router);
		((BridgeRouter) router).setIdentity(identityKey.getFingerprint());
	} else if(!identityKey.getFingerprint().equals(router.getIdentityHash())) {
		throw new ConnectionHandshakeException("Router identity does not match certificate key");
	}
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
public TorPublicKey getIdentityKey() {
	final RouterDescriptor rd = downcastDescriptor();
	if(rd != null) {
		return rd.getIdentityKey();
	} else {
		return null;
	}
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
public TorPublicKey getOnionKey() {
	refreshDescriptor();
	if(descriptor != null) {
		return descriptor.getOnionKey();
	} else {
		return null;
	}
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
public TorPublicKey getOnionKey() {
	if(descriptor != null) {
		return descriptor.getOnionKey();
	} else {
		return null;
	}
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
private byte[] encryptIntroductionBuffer(ByteBuffer buffer, TorPublicKey key) {
	final int len = buffer.position();
	final byte[] payload = new byte[len];
	buffer.flip();
	buffer.get(payload);
	final HybridEncryption enc = new HybridEncryption();
	return enc.encrypt(payload, key);
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
public TorPublicKey getAuthorityIdentityKey() {
	return identityKey;
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
public TorPublicKey getAuthoritySigningKey() {
	return signingKey;
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
private void verifyCrossSignature(TorSignature crossSignature) {
	TorPublicKey identityKey = currentCertificate.getAuthorityIdentityKey();
	TorPublicKey signingKey = currentCertificate.getAuthoritySigningKey();
	if(!signingKey.verifySignature(crossSignature, identityKey.getFingerprint())) 
		throw new TorParsingException("Cross signature on certificate failed.");
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
public TorPublicKey parsePublicKey() {
	final DocumentObject documentObject = parseObject();
	return TorPublicKey.createFromPEMBuffer(documentObject.getContent());
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
public boolean verifySignedEntity(TorPublicKey publicKey, TorSignature signature) {
	isProcessingSignedEntity = false;
	return publicKey.verifySignature(signature, signatureDigest);
}
 

import com.subgraph.orchid.crypto.TorPublicKey; //导入依赖的package包/类
public void setOnionKey(TorPublicKey onionKey) {
	this.onionKey = onionKey;
}