// Copyright (C) 2001-2003, 2022 VeriSign, Inc.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA

package com.verisignlabs.dnssec.security;

import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.time.Instant;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.logging.Logger;

import org.xbill.DNS.DNSKEYRecord;
import org.xbill.DNS.DNSSEC;
import org.xbill.DNS.Name;
import org.xbill.DNS.RRSIGRecord;
import org.xbill.DNS.RRset;

/**
 * A class for performing basic DNSSEC verification. The DNSJAVA package
 * contains a similar class. This differs (for the moment, anyway) by allowing
 * timing "fudge" factors and logging more specifically why an RRset did not
 * validate.
 * 
 * @author David Blacka
 */
public class DnsSecVerifier {

  private class TrustedKeyStore {
    // for now, this is implemented as a hash table of lists of
    // DnsKeyPair objects (obviously, all of them will not have
    // private keys).
    private HashMap<String, List<DnsKeyPair>> mKeyMap;

    public TrustedKeyStore() {
      mKeyMap = new HashMap<>();
    }

    public void add(DnsKeyPair pair) {
      String n = pair.getDNSKEYName().toString().toLowerCase();
      List<DnsKeyPair> l = mKeyMap.computeIfAbsent(n, k -> new ArrayList<>());
      l.add(pair);
    }

    public void add(DNSKEYRecord keyrec) {
      DnsKeyPair pair = new DnsKeyPair(keyrec, (PrivateKey) null);
      add(pair);
    }

    public void add(Name name, int algorithm, PublicKey key) {
      DnsKeyPair pair = new DnsKeyPair(name, algorithm, key, null);
      add(pair);
    }

    public DnsKeyPair find(Name name, int algorithm, int keyid) {
      String n = name.toString().toLowerCase();
      List<DnsKeyPair> l = mKeyMap.get(n);
      if (l == null)
        return null;

      // FIXME: this algorithm assumes that name+alg+footprint is
      // unique, which isn't necessarily true.
      for (DnsKeyPair p : l) {
        if (p.getDNSKEYAlgorithm() == algorithm && p.getDNSKEYFootprint() == keyid) {
          return p;
        }
      }
      return null;
    }
  }

  private TrustedKeyStore mKeyStore;
  private int mStartFudge = 0;
  private int mExpireFudge = 0;
  private boolean mVerifyAllSigs = false;
  private boolean mIgnoreTime = false;

  private Logger log;

  public DnsSecVerifier() {
    log = Logger.getLogger(this.getClass().toString());

    mKeyStore = new TrustedKeyStore();
  }

  public void addTrustedKey(DNSKEYRecord keyrec) {
    mKeyStore.add(keyrec);
  }

  public void addTrustedKey(DnsKeyPair pair) {
    mKeyStore.add(pair);
  }

  public void addTrustedKey(Name name, int algorithm, PublicKey key) {
    mKeyStore.add(name, algorithm, key);
  }

  public void addTrustedKey(Name name, PublicKey key) {
    mKeyStore.add(name, 0, key);
  }

  public void setExpireFudge(int fudge) {
    mExpireFudge = fudge;
  }

  public void setStartFudge(int fudge) {
    mStartFudge = fudge;
  }

  public void setVerifyAllSigs(boolean v) {
    mVerifyAllSigs = v;
  }

  public void setIgnoreTime(boolean v) {
    mIgnoreTime = v;
  }

  private DnsKeyPair findKey(Name name, int algorithm, int footprint) {
    return mKeyStore.find(name, algorithm, footprint);
  }

  private boolean validateSignature(RRset rrset, RRSIGRecord sigrec, List<String> reasons) {
    if (rrset == null || sigrec == null)
      return false;
    if (!rrset.getName().equals(sigrec.getName())) {
      log.fine("Signature name does not match RRset name");
      if (reasons != null)
        reasons.add("Signature name does not match RRset name");
      return false;
    }
    if (rrset.getType() != sigrec.getTypeCovered()) {
      log.fine("Signature type does not match RRset type");
      if (reasons != null)
        reasons.add("Signature type does not match RRset type");
    }

    if (mIgnoreTime)
      return true;

    Instant now = Instant.now();
    Instant start = sigrec.getTimeSigned();
    Instant expire = sigrec.getExpire();

    if (mStartFudge >= 0) {
      if (mStartFudge > 0) {
        start = start.minusSeconds(mStartFudge);
      }
      if (now.isBefore(start)) {
        log.fine("Signature is not yet valid");
        if (reasons != null)
          reasons.add("Signature not yet valid");
        return false;
      }
    }

    if (mExpireFudge >= 0) {
      if (mExpireFudge > 0) {
        expire = expire.plusSeconds(mExpireFudge);
      }
      if (now.isAfter(expire)) {
        log.fine("Signature has expired (now = " + now + ", sig expires = " + expire);
        if (reasons != null)
          reasons.add("Signature has expired.");
        return false;
      }
    }

    if (rrset.getTTL() > sigrec.getOrigTTL()) {
      log.fine("RRset's TTL is greater than the Signature's orignal TTL");
      if (reasons != null)
        reasons.add("RRset TTL greater than RRSIG origTTL");
      return false;
    }

    return true;
  }

  public boolean verifySignature(RRset rrset, RRSIGRecord sigrec) {
    return verifySignature(rrset, sigrec, null);
  }

  /**
   * Verify an RRset against a particular signature.
   * 
   * @return true if the signature verified, false if it did
   *         not verify (for any reason, including not finding the DNSKEY.)
   */
  public boolean verifySignature(RRset rrset, RRSIGRecord sigrec, List<String> reasons) {
    boolean result = validateSignature(rrset, sigrec, reasons);
    if (!result)
      return result;

    DnsKeyPair keypair = findKey(sigrec.getSigner(), sigrec.getAlgorithm(),
        sigrec.getFootprint());

    if (keypair == null) {
      if (reasons != null)
        reasons.add("Could not find matching trusted key");
      log.fine("could not find matching trusted key");
      return false;
    }

    try {
      byte[] data = SignUtils.generateSigData(rrset, sigrec);

      DnsKeyAlgorithm algs = DnsKeyAlgorithm.getInstance();

      Signature signer = keypair.getVerifier();
      signer.update(data);

      byte[] sig = sigrec.getSignature();

      if (algs.baseType(sigrec.getAlgorithm()) == DnsKeyAlgorithm.DSA) {
        sig = SignUtils.convertDSASignature(sig);
      }

      if (sigrec.getAlgorithm() == DNSSEC.Algorithm.ECDSAP256SHA256 ||
          sigrec.getAlgorithm() == DNSSEC.Algorithm.ECDSAP384SHA384) {
        sig = SignUtils.convertECDSASignature(sig);
      }

      if (!signer.verify(sig)) {
        if (reasons != null)
          reasons.add("Signature failed to verify cryptographically");
        log.fine("Signature failed to verify cryptographically");
        return false;
      }

      return true;
    } catch (IOException e) {
      log.severe("I/O error: " + e);
    } catch (GeneralSecurityException e) {
      log.severe("Security error: " + e);
    }
    if (reasons != null)
      reasons.add("Signature failed to verify due to exception");
    log.fine("Signature failed to verify due to exception");
    return false;
  }

  /**
   * Verifies an RRset. This routine does not modify the RRset.
   * 
   * @return true if the set verified, false if it did not.
   */
  public boolean verify(RRset rrset) {
    boolean result = mVerifyAllSigs ? true : false;

    if (rrset.sigs().isEmpty()) {
      log.fine("RRset failed to verify due to lack of signatures");
      return false;
    }
    for (RRSIGRecord sigrec : rrset.sigs()) {

      boolean res = verifySignature(rrset, sigrec);

      // If not requiring all signature to validate, then any successful validation is
      // sufficient.
      if (!mVerifyAllSigs && res)
        return res;

      // Otherwise, note if a signature failed to validate.
      if (mVerifyAllSigs && !res) {
        result = res;
      }
    }

    return result;
  }
}