src/com/versign/tat/dnssec/SignUtils.java

   1 /***************************** -*- Java -*- ********************************\
   2  *                                                                         *
   3  *   Copyright (c) 2009 VeriSign, Inc. All rights reserved.                *
   4  *                                                                         *
   5  * This software is provided solely in connection with the terms of the    *
   6  * license agreement.  Any other use without the prior express written     *
   7  * permission of VeriSign is completely prohibited.  The software and      *
   8  * documentation are "Commercial Items", as that term is defined in 48     *
   9  * C.F.R.  section 2.101, consisting of "Commercial Computer Software" and *
  10  * "Commercial Computer Software Documentation" as such terms are defined  *
  11  * in 48 C.F.R. section 252.227-7014(a)(5) and 48 C.F.R. section           *
  12  * 252.227-7014(a)(1), and used in 48 C.F.R. section 12.212 and 48 C.F.R.  *
  13  * section 227.7202, as applicable.  Pursuant to the above and other       *
  14  * relevant sections of the Code of Federal Regulations, as applicable,    *
  15  * VeriSign's publications, commercial computer software, and commercial   *
  16  * computer software documentation are distributed and licensed to United  *
  17  * States Government end users with only those rights as granted to all    *
  18  * other end users, according to the terms and conditions contained in the *
  19  * license agreement(s) that accompany the products and software           *
  20  * documentation.                                                          *
  21  *                                                                         *
  22 \***************************************************************************/
  23
  24 package com.verisign.tat.dnssec;
  25
  26 import org.apache.log4j.Logger;
  27
  28 import org.xbill.DNS.DNSKEYRecord;
  29 import org.xbill.DNS.DNSOutput;
  30 import org.xbill.DNS.Name;
  31 import org.xbill.DNS.RRSIGRecord;
  32 import org.xbill.DNS.RRset;
  33 import org.xbill.DNS.Record;
  34 import org.xbill.DNS.utils.base64;
  35
  36 import java.io.ByteArrayOutputStream;
  37 import java.io.IOException;
  38
  39 import java.security.SignatureException;
  40 import java.security.interfaces.DSAParams;
  41
  42 import java.util.ArrayList;
  43 import java.util.Arrays;
  44 import java.util.Collections;
  45 import java.util.Comparator;
  46 import java.util.Date;
  47 import java.util.Iterator;
  48
  49
  50 /**
  51  * This class contains a bunch of utility methods that are generally useful in
  52  * signing and verifying rrsets.
  53  */
  54 public class SignUtils {
  55     // private static final int DSA_SIGNATURE_LENGTH = 20;
  56     private static final int ASN1_INT      = 0x02;
  57     private static final int ASN1_SEQ      = 0x30;
  58     public static final int  RR_NORMAL     = 0;
  59     public static final int  RR_DELEGATION = 1;
  60     public static final int  RR_GLUE       = 2;
  61     public static final int  RR_INVALID    = 3;
  62     private static Logger    log           = Logger.getLogger(SignUtils.class);
  63
  64     /**
  65      * Generate from some basic information a prototype SIG RR containing
  66      * everything but the actual signature itself.
  67      *
  68      * @param rrset
  69      *            the RRset being signed.
  70      * @param signer
  71      *            the name of the signing key
  72      * @param alg
  73      *            the algorithm of the signing key
  74      * @param keyid
  75      *            the keyid (or footprint) of the signing key
  76      * @param start
  77      *            the SIG inception time.
  78      * @param expire
  79      *            the SIG expiration time.
  80      * @param sig_ttl
  81      *            the TTL of the resulting SIG record.
  82      * @return a prototype signature based on the RRset and key information.
  83      */
  84     public static RRSIGRecord generatePreRRSIG(RRset rrset, Name signer,
  85         int alg, int keyid, Date start, Date expire, long sig_ttl) {
  86         return new RRSIGRecord(rrset.getName(), rrset.getDClass(), sig_ttl,
  87             rrset.getType(), alg, rrset.getTTL(), expire, start, keyid, signer,
  88             null);
  89     }
  90
  91     /**
  92      * Generate from some basic information a prototype SIG RR containing
  93      * everything but the actual signature itself.
  94      *
  95      * @param rrset
  96      *            the RRset being signed.
  97      * @param key
  98      *            the public KEY RR counterpart to the key being used to sign
  99      *            the RRset
 100      * @param start
 101      *            the SIG inception time.
 102      * @param expire
 103      *            the SIG expiration time.
 104      * @param sig_ttl
 105      *            the TTL of the resulting SIG record.
 106      * @return a prototype signature based on the RRset and key information.
 107      */
 108     public static RRSIGRecord generatePreRRSIG(RRset rrset, DNSKEYRecord key,
 109         Date start, Date expire, long sig_ttl) {
 110         return generatePreRRSIG(rrset, key.getName(), key.getAlgorithm(),
 111             key.getFootprint(), start, expire, sig_ttl);
 112     }
 113
 114     /**
 115      * Generate from some basic information a prototype SIG RR containing
 116      * everything but the actual signature itself.
 117      *
 118      * @param rec
 119      *            the DNS record being signed (forming an entire RRset).
 120      * @param key
 121      *            the public KEY RR counterpart to the key signing the record.
 122      * @param start
 123      *            the SIG inception time.
 124      * @param expire
 125      *            the SIG expiration time.
 126      * @param sig_ttl
 127      *            the TTL of the result SIG record.
 128      * @return a prototype signature based on the Record and key information.
 129      */
 130     public static RRSIGRecord generatePreRRSIG(Record rec, DNSKEYRecord key,
 131         Date start, Date expire, long sig_ttl) {
 132         return new RRSIGRecord(rec.getName(), rec.getDClass(), sig_ttl,
 133             rec.getType(), key.getAlgorithm(), rec.getTTL(), expire, start,
 134             key.getFootprint(), key.getName(), null);
 135     }
 136
 137     /**
 138      * Generate the binary image of the prototype SIG RR.
 139      *
 140      * @param presig
 141      *            the SIG RR prototype.
 142      * @return the RDATA portion of the prototype SIG record. This forms the
 143      *         first part of the data to be signed.
 144      */
 145     private static byte [] generatePreSigRdata(RRSIGRecord presig) {
 146         // Generate the binary image;
 147         DNSOutput image = new DNSOutput();
 148
 149         // precalculate some things
 150         int  start_time  = (int) (presig.getTimeSigned().getTime() / 1000);
 151         int  expire_time = (int) (presig.getExpire().getTime() / 1000);
 152         Name signer      = presig.getSigner();
 153
 154         // first write out the partial SIG record (this is the SIG RDATA
 155         // minus the actual signature.
 156         image.writeU16(presig.getTypeCovered());
 157         image.writeU8(presig.getAlgorithm());
 158         image.writeU8(presig.getLabels());
 159         image.writeU32((int) presig.getOrigTTL());
 160         image.writeU32(expire_time);
 161         image.writeU32(start_time);
 162         image.writeU16(presig.getFootprint());
 163         image.writeByteArray(signer.toWireCanonical());
 164
 165         return image.toByteArray();
 166     }
 167
 168     /**
 169      * Calculate the canonical wire line format of the RRset.
 170      *
 171      * @param rrset
 172      *            the RRset to convert.
 173      * @param ttl
 174      *            the TTL to use when canonicalizing -- this is generally the
 175      *            TTL of the signature if there is a pre-existing signature. If
 176      *            not it is just the ttl of the rrset itself.
 177      * @param labels
 178      *            the labels field of the signature, or 0.
 179      * @return the canonical wire line format of the rrset. This is the second
 180      *         part of data to be signed.
 181      */
 182     @SuppressWarnings("unchecked")
 183     public static byte [] generateCanonicalRRsetData(RRset rrset, long ttl,
 184         int labels) {
 185         DNSOutput image = new DNSOutput();
 186
 187         if (ttl == 0) {
 188             ttl = rrset.getTTL();
 189         }
 190
 191         Name n = rrset.getName();
 192
 193         if (labels == 0) {
 194             labels = n.labels();
 195         } else {
 196             // correct for Name()'s conception of label count.
 197             labels++;
 198         }
 199
 200         boolean wildcardName = false;
 201
 202         if (n.labels() != labels) {
 203             n                = n.wild(n.labels() - labels);
 204             wildcardName     = true;
 205             log.trace("Detected wildcard expansion: " + rrset.getName() +
 206                 " changed to " + n);
 207         }
 208
 209         // now convert the wire format records in the RRset into a
 210         // list of byte arrays.
 211         ArrayList<byte []> canonical_rrs = new ArrayList<byte []>();
 212
 213         for (Iterator i = rrset.rrs(); i.hasNext();) {
 214             Record r = (Record) i.next();
 215
 216             if ((r.getTTL() != ttl) || wildcardName) {
 217                 // If necessary, we need to create a new record with a new ttl
 218                 // or ownername.
 219                 // In the TTL case, this avoids changing the ttl in the
 220                 // response.
 221                 r = Record.newRecord(n, r.getType(), r.getDClass(), ttl,
 222                         r.rdataToWireCanonical());
 223             }
 224
 225             byte [] wire_fmt = r.toWireCanonical();
 226             canonical_rrs.add(wire_fmt);
 227         }
 228
 229         // put the records into the correct ordering.
 230         // Calculate the offset where the RDATA begins (we have to skip
 231         // past the length byte)
 232         int                 offset = rrset.getName().toWireCanonical().length +
 233             10;
 234         ByteArrayComparator bac    = new ByteArrayComparator(offset, false);
 235
 236         Collections.sort(canonical_rrs, bac);
 237
 238         for (Iterator<byte []> i = canonical_rrs.iterator(); i.hasNext();) {
 239             byte [] wire_fmt_rec = i.next();
 240             image.writeByteArray(wire_fmt_rec);
 241         }
 242
 243         return image.toByteArray();
 244     }
 245
 246     /**
 247      * Given an RRset and the prototype signature, generate the canonical data
 248      * that is to be signed.
 249      *
 250      * @param rrset
 251      *            the RRset to be signed.
 252      * @param presig
 253      *            a prototype SIG RR created using the same RRset.
 254      * @return a block of data ready to be signed.
 255      */
 256     public static byte [] generateSigData(RRset rrset, RRSIGRecord presig)
 257         throws IOException {
 258         byte [] rrset_data = generateCanonicalRRsetData(rrset,
 259                 presig.getOrigTTL(), presig.getLabels());
 260
 261         return generateSigData(rrset_data, presig);
 262     }
 263
 264     /**
 265      * Given an RRset and the prototype signature, generate the canonical data
 266      * that is to be signed.
 267      *
 268      * @param rrset_data
 269      *            the RRset converted into canonical wire line format (as per
 270      *            the canonicalization rules in RFC 2535).
 271      * @param presig
 272      *            the prototype signature based on the same RRset represented in
 273      *            <code>rrset_data</code>.
 274      * @return a block of data ready to be signed.
 275      */
 276     public static byte [] generateSigData(byte [] rrset_data, RRSIGRecord presig)
 277         throws IOException {
 278         byte []               sig_rdata = generatePreSigRdata(presig);
 279
 280         ByteArrayOutputStream image     = new ByteArrayOutputStream(sig_rdata.length +
 281                 rrset_data.length);
 282
 283         image.write(sig_rdata);
 284         image.write(rrset_data);
 285
 286         return image.toByteArray();
 287     }
 288
 289     /**
 290      * Given the actual signature and the prototype signature, combine them and
 291      * return the fully formed RRSIGRecord.
 292      *
 293      * @param signature
 294      *            the cryptographic signature, in DNSSEC format.
 295      * @param presig
 296      *            the prototype RRSIG RR to add the signature to.
 297      * @return the fully formed RRSIG RR.
 298      */
 299     public static RRSIGRecord generateRRSIG(byte [] signature,
 300         RRSIGRecord presig) {
 301         return new RRSIGRecord(presig.getName(), presig.getDClass(),
 302             presig.getTTL(), presig.getTypeCovered(), presig.getAlgorithm(),
 303             presig.getOrigTTL(), presig.getExpire(), presig.getTimeSigned(),
 304             presig.getFootprint(), presig.getSigner(), signature);
 305     }
 306
 307     /**
 308      * Converts from a RFC 2536 formatted DSA signature to a JCE (ASN.1)
 309      * formatted signature.
 310      *
 311      * <p>
 312      * ASN.1 format = ASN1_SEQ . seq_length . ASN1_INT . Rlength . R . ANS1_INT
 313      * . Slength . S
 314      * </p>
 315      *
 316      * The integers R and S may have a leading null byte to force the integer
 317      * positive.
 318      *
 319      * @param signature
 320      *            the RFC 2536 formatted DSA signature.
 321      * @return The ASN.1 formatted DSA signature.
 322      * @throws SignatureException
 323      *             if there was something wrong with the RFC 2536 formatted
 324      *             signature.
 325      */
 326     public static byte [] convertDSASignature(byte [] signature)
 327         throws SignatureException {
 328         if (signature.length != 41) {
 329             throw new SignatureException(
 330                 "RFC 2536 signature not expected length.");
 331         }
 332
 333         byte r_pad = 0;
 334         byte s_pad = 0;
 335
 336         // handle initial null byte padding.
 337         if (signature[1] < 0) {
 338             r_pad++;
 339         }
 340
 341         if (signature[21] < 0) {
 342             s_pad++;
 343         }
 344
 345         // ASN.1 length = R length + S length + (2 + 2 + 2), where each 2
 346         // is for a ASN.1 type-length byte pair of which there are three
 347         // (SEQ, INT, INT).
 348         byte    sig_length = (byte) (40 + r_pad + s_pad + 6);
 349
 350         byte [] sig        = new byte[sig_length];
 351         byte    pos        = 0;
 352
 353         sig[pos++]         = ASN1_SEQ;
 354         sig[pos++]         = (byte) (sig_length - 2); // all but the SEQ type+length.
 355         sig[pos++]         = ASN1_INT;
 356         sig[pos++]         = (byte) (20 + r_pad);
 357
 358         // copy the value of R, leaving a null byte if necessary
 359         if (r_pad == 1) {
 360             sig[pos++] = 0;
 361         }
 362
 363         System.arraycopy(signature, 1, sig, pos, 20);
 364         pos += 20;
 365
 366         sig[pos++]     = ASN1_INT;
 367         sig[pos++]     = (byte) (20 + s_pad);
 368
 369         // copy the value of S, leaving a null byte if necessary
 370         if (s_pad == 1) {
 371             sig[pos++] = 0;
 372         }
 373
 374         System.arraycopy(signature, 21, sig, pos, 20);
 375
 376         return sig;
 377     }
 378
 379     /**
 380      * Converts from a JCE (ASN.1) formatted DSA signature to a RFC 2536
 381      * compliant signature.
 382      *
 383      * <p>
 384      * rfc2536 format = T . R . S
 385      * </p>
 386      *
 387      * where T is a number between 0 and 8, which is based on the DSA key
 388      * length, and R & S are formatted to be exactly 20 bytes each (no leading
 389      * null bytes).
 390      *
 391      * @param params
 392      *            the DSA parameters associated with the DSA key used to
 393      *            generate the signature.
 394      * @param signature
 395      *            the ASN.1 formatted DSA signature.
 396      * @return a RFC 2536 formatted DSA signature.
 397      * @throws SignatureException
 398      *             if something is wrong with the ASN.1 format.
 399      */
 400     public static byte [] convertDSASignature(DSAParams params,
 401         byte [] signature) throws SignatureException {
 402         if ((signature[0] != ASN1_SEQ) || (signature[2] != ASN1_INT)) {
 403             throw new SignatureException(
 404                 "Invalid ASN.1 signature format: expected SEQ, INT");
 405         }
 406
 407         byte r_pad = (byte) (signature[3] - 20);
 408
 409         if (signature[24 + r_pad] != ASN1_INT) {
 410             throw new SignatureException(
 411                 "Invalid ASN.1 signature format: expected SEQ, INT, INT");
 412         }
 413
 414         log.trace("(start) ASN.1 DSA Sig:\n" + base64.toString(signature));
 415
 416         byte    s_pad = (byte) (signature[25 + r_pad] - 20);
 417
 418         byte [] sig   = new byte[41]; // all rfc2536 signatures are 41 bytes.
 419
 420         // Calculate T:
 421         sig[0] = (byte) ((params.getP().bitLength() - 512) / 64);
 422
 423         // copy R value
 424         if (r_pad >= 0) {
 425             System.arraycopy(signature, 4 + r_pad, sig, 1, 20);
 426         } else {
 427             // R is shorter than 20 bytes, so right justify the number
 428             // (r_pad is negative here, remember?).
 429             Arrays.fill(sig, 1, 1 - r_pad, (byte) 0);
 430             System.arraycopy(signature, 4, sig, 1 - r_pad, 20 + r_pad);
 431         }
 432
 433         // copy S value
 434         if (s_pad >= 0) {
 435             System.arraycopy(signature, 26 + r_pad + s_pad, sig, 21, 20);
 436         } else {
 437             // S is shorter than 20 bytes, so right justify the number
 438             // (s_pad is negative here).
 439             Arrays.fill(sig, 21, 21 - s_pad, (byte) 0);
 440             System.arraycopy(signature, 26 + r_pad, sig, 21 - s_pad, 20 +
 441                 s_pad);
 442         }
 443
 444         if ((r_pad < 0) || (s_pad < 0)) {
 445             log.trace("(finish ***) RFC 2536 DSA Sig:\n" +
 446                 base64.toString(sig));
 447         } else {
 448             log.trace("(finish) RFC 2536 DSA Sig:\n" + base64.toString(sig));
 449         }
 450
 451         return sig;
 452     }
 453
 454     /**
 455      * This class implements a basic comparator for byte arrays. It is primarily
 456      * useful for comparing RDATA portions of DNS records in doing DNSSEC
 457      * canonical ordering.
 458      */
 459     public static class ByteArrayComparator implements Comparator<byte []> {
 460         private int     mOffset = 0;
 461         private boolean mDebug  = false;
 462
 463         public ByteArrayComparator() {}
 464
 465         public ByteArrayComparator(int offset, boolean debug) {
 466             mOffset     = offset;
 467             mDebug      = debug;
 468         }
 469
 470         public int compare(byte [] b1, byte [] b2) throws ClassCastException {
 471             for (int i = mOffset; (i < b1.length) && (i < b2.length); i++) {
 472                 if (b1[i] != b2[i]) {
 473                     if (mDebug) {
 474                         System.out.println("offset " + i +
 475                             " differs (this is " + (i - mOffset) +
 476                             " bytes in from our offset.)");
 477                     }
 478
 479                     return (b1[i] & 0xFF) - (b2[i] & 0xFF);
 480                 }
 481             }
 482
 483             return b1.length - b2.length;
 484         }
 485     }
 486 }