import com.subgraph.orchid.DirectoryServer; //导入依赖的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.DirectoryServer; //导入依赖的package包/类
public void addCertificate(KeyCertificate certificate) {
	synchronized(TrustedAuthorities.getInstance()) {
		final boolean wasRequired = removeRequiredCertificate(certificate);
		final DirectoryServer as = TrustedAuthorities.getInstance().getAuthorityServerByIdentity(certificate.getAuthorityFingerprint());
		if(as == null) {
			logger.warning("Certificate read for unknown directory authority with identity: "+ certificate.getAuthorityFingerprint());
			return;
		}
		as.addCertificate(certificate);
		
		if(consensusWaitingForCertificates != null && wasRequired) {
			
			switch(consensusWaitingForCertificates.verifySignatures()) {
			case STATUS_FAILED:
				consensusWaitingForCertificates = null;
				return;
				
			case STATUS_VERIFIED:
				addConsensusDocument(consensusWaitingForCertificates, false);
				consensusWaitingForCertificates = null;
				return;

			case STATUS_NEED_CERTS:
				requiredCertificates.addAll(consensusWaitingForCertificates.getRequiredCertificates());
				return;
			}
		}
	}
}
 

import com.subgraph.orchid.DirectoryServer; //导入依赖的package包/类
public void storeCertificates() {
	synchronized(TrustedAuthorities.getInstance()) {
		final List<KeyCertificate> certs = new ArrayList<KeyCertificate>();
		for(DirectoryServer ds: TrustedAuthorities.getInstance().getAuthorityServers()) {
			certs.addAll(ds.getCertificates());
		}
		store.writeDocumentList(CacheFile.CERTIFICATES, certs);
	}
}
 

import com.subgraph.orchid.DirectoryServer; //导入依赖的package包/类
private int countV3Servers() {
	int n = 0;
	for(DirectoryServer ds: directoryServers) {
		if(ds.getV3Identity() != null) {
			n += 1;
		}
	}
	return n;
}
 

import com.subgraph.orchid.DirectoryServer; //导入依赖的package包/类
public DirectoryServer getAuthorityServerByIdentity(HexDigest identity) {
	for(DirectoryServer ds: directoryServers) {
		if(identity.equals(ds.getV3Identity())) {
			return ds;
		}
	}
	return null;
}
 

import com.subgraph.orchid.DirectoryServer; //导入依赖的package包/类
private SignatureStatus verifySingleAuthority(VoteAuthorityEntry authority) {
	
	boolean certsNeeded = false;
	boolean validSignature = false;
	
	for(DirectorySignature s: authority.getSignatures()) {
		DirectoryServer trusted = TrustedAuthorities.getInstance().getAuthorityServerByIdentity(s.getIdentityDigest());
		if(trusted == null) {
			logger.warning("Consensus signed by unrecognized directory authority: "+ s.getIdentityDigest());
			return SignatureStatus.STATUS_FAILED;
		} else {
			switch(verifySignatureForTrustedAuthority(trusted, s)) {
			case STATUS_NEED_CERTS:
				certsNeeded = true;
				break;
			case STATUS_VERIFIED:
				validSignature = true;
				break;
			default:
				break;
			}
		}
	}
	
	if(validSignature) {
		return SignatureStatus.STATUS_VERIFIED;
	} else if(certsNeeded) {
		return SignatureStatus.STATUS_NEED_CERTS;
	} else {
		return SignatureStatus.STATUS_FAILED;
	}
}