org.xbill.DNS.KEYBase Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ddns-dnsjava Show documentation
DiscoveryDNS fork of DNSJava project
There is a newer version: 1.1.8-r1685
// Copyright (c) 1999-2004 Brian Wellington ([email protected])

package org.xbill.DNS;

import java.io.IOException;
import java.security.PublicKey;

import org.xbill.DNS.utils.base64;

/**
 * The base class for KEY/DNSKEY records, which have identical formats
 * 
 * @author Brian Wellington
 */

abstract class KEYBase extends Record {

	private static final long serialVersionUID = 3469321722693285454L;

	protected int flags, proto, alg;
	protected byte[] key;
	protected int footprint = -1;
	protected PublicKey publicKey = null;

	protected KEYBase() {
	}

	public KEYBase(Name name, int type, int dclass, long ttl, int flags,
			int proto, int alg, byte[] key) {
		super(name, type, dclass, ttl);
		this.flags = checkU16("flags", flags);
		this.proto = checkU8("proto", proto);
		this.alg = checkU8("alg", alg);
		this.key = key;
	}

	void rrFromWire(DNSInput in) throws IOException {
		flags = in.readU16();
		proto = in.readU8();
		alg = in.readU8();
		if (in.remaining() > 0)
			key = in.readByteArray();
	}

	/** Converts the DNSKEY/KEY Record to a String */
	String rrToString() {
		StringBuffer sb = new StringBuffer();
		sb.append(flags);
		sb.append(" ");
		sb.append(proto);
		sb.append(" ");
		sb.append(alg);
		if (key != null) {
			if (Options.check("multiline")) {
				sb.append(" (\n");
				sb.append(base64.formatString(key, 64, "\t", true));
				sb.append(" ; key_tag = ");
				sb.append(getFootprint());
			} else {
				sb.append(" ");
				sb.append(base64.toString(key));
			}
		}
		return sb.toString();
	}

	public String getTextualPublicKey() {
		return base64.toString(key);
	}

	/**
	 * Returns the flags describing the key's properties
	 */
	public int getFlags() {
		return flags;
	}

	/**
	 * Returns the protocol that the key was created for
	 */
	public int getProtocol() {
		return proto;
	}

	/**
	 * Returns the key's algorithm
	 */
	public int getAlgorithm() {
		return alg;
	}

	/**
	 * Returns the binary data representing the key
	 */
	public byte[] getKey() {
		return key;
	}

	/**
	 * Returns the key's footprint (after computing it)
	 */
	public int getFootprint() {
		if (footprint >= 0)
			return footprint;

		int foot = 0;

		DNSOutput out = new DNSOutput();
		rrToWire(out, null, false);
		byte[] rdata = out.toByteArray();

		if (alg == DNSSEC.Algorithm.RSAMD5) {
			int d1 = rdata[rdata.length - 3] & 0xFF;
			int d2 = rdata[rdata.length - 2] & 0xFF;
			foot = (d1 << 8) + d2;
		} else {
			int i;
			for (i = 0; i < rdata.length - 1; i += 2) {
				int d1 = rdata[i] & 0xFF;
				int d2 = rdata[i + 1] & 0xFF;
				foot += ((d1 << 8) + d2);
			}
			if (i < rdata.length) {
				int d1 = rdata[i] & 0xFF;
				foot += (d1 << 8);
			}
			foot += ((foot >> 16) & 0xFFFF);
		}
		footprint = (foot & 0xFFFF);
		return footprint;
	}

	/**
	 * Returns a PublicKey corresponding to the data in this key.
	 * 
	 * @throws DNSSEC.DNSSECException
	 *             The key could not be converted.
	 */
	public PublicKey getPublicKey() throws DNSSEC.DNSSECException {
		if (publicKey != null)
			return publicKey;

		publicKey = DNSSEC.toPublicKey(this);
		return publicKey;
	}

	void rrToWire(DNSOutput out, Compression c, boolean canonical) {
		out.writeU16(flags);
		out.writeU8(proto);
		out.writeU8(alg);
		if (key != null)
			out.writeByteArray(key);
	}

}