public static String resolve(String host, int addrType) { try { Lookup lookup = new Lookup(host, addrType); SimpleResolver resolver = new SimpleResolver("114.114.114.114"); resolver.setTimeout(5); lookup.setResolver(resolver); Record[] result = lookup.run(); if (result == null) return null; List<Record> records = java.util.Arrays.asList(result); java.util.Collections.shuffle(records); for (Record record : records) { if (addrType == Type.A) { return ((ARecord) record).getAddress().getHostAddress(); } else if (addrType == Type.AAAA) { return ((AAAARecord) record).getAddress().getHostAddress(); } } } catch (Exception ex) { return null; } return null; }
/** * reverse lookup an IP address using a specified DNS host and port * * @param resolverHost name server hostname or IP address * @param resolverPort name server port * @param address the IP address to reverse lookup * @return a comma separated list of names or an empty string when unable to resolve */ public String reverseLookupByAddress(String resolverHost, int resolverPort, InetAddress address) { try { SimpleResolver resolver = new SimpleResolver(resolverHost); resolver.setPort(resolverPort); Lookup lookup = new Lookup(fromAddress(address), PTR); Record[] records = lookup.run(); if (records != null) { List<String> addresses = of(records) .filter(it -> it instanceof PTRRecord) .map(it -> ((PTRRecord) it).getTarget().toString()) .collect(toList()); return collectionToCommaDelimitedString(addresses); } else { return ""; } } catch (UnknownHostException e) { log.warn("unable to resolve using SRV record " + address, e); return ""; } }
public static String reverseDNSLookup(final InetAddress adr) { try { final Name name = ReverseMap.fromAddress(adr); final Lookup lookup = new Lookup(name, Type.PTR); lookup.setResolver(new SimpleResolver()); lookup.setCache(null); final Record[] records = lookup.run(); if (lookup.getResult() == Lookup.SUCCESSFUL) for (final Record record : records) if (record instanceof PTRRecord) { final PTRRecord ptr = (PTRRecord) record; return ptr.getTarget().toString(); } } catch (final Exception e) { } return null; }
/** * resolves an A record by its name using a specified DNS host and port * * @param resolverHost name server hostname or IP address * @param resolverPort name server port * @param name the DNS name of the A record - the name to resolve * @return a comma separated list of IP addresses or an empty string when unable to resolve */ public String resolveHostByName(String resolverHost, int resolverPort, String name) { try { SimpleResolver resolver = new SimpleResolver(resolverHost); resolver.setPort(resolverPort); Lookup lookup = new Lookup(name, A); Record[] records = lookup.run(); if (records != null) { List<String> addresses = of(records) .filter(it -> it instanceof ARecord) .map(it -> ((ARecord) it).getAddress().getHostAddress()) .collect(toList()); return collectionToCommaDelimitedString(addresses); } else { return ""; } } catch (UnknownHostException | TextParseException e) { log.warn("unable to resolve using A record " + name, e); return ""; } }
/** * resolves the TXT field for a given name using a specified DNS host and port. This is useful, for example, * if you want to resolve abusers with: <a href="https://abusix.com/contactdb.html">https://abusix.com/contactdb.html</a> * * @param resolverHost name server hostname or IP address * @param resolverPort name server port * @param name the DNS name of the TXT record - the name to resolve * @return the resolved text */ public String resolveTextByName(String resolverHost, int resolverPort, String name) { try { SimpleResolver resolver = new SimpleResolver(resolverHost); resolver.setPort(resolverPort); Lookup lookup = new Lookup(name, TXT); Record[] records = lookup.run(); if (records != null) { List<String> addresses = of(records) .filter(it -> it instanceof TXTRecord) .map(it -> collectionToCommaDelimitedString(((TXTRecord) it).getStrings())) .collect(toList()); return collectionToCommaDelimitedString(addresses); } else { return ""; } } catch (UnknownHostException | TextParseException e) { log.warn("unable to resolve using TXT record " + name, e); return ""; } }
/** * Private helper to instantiate a DNS <code>Resolver</code> by the provided Server. * * @param dnsSec <code>true</code> iff DNSSEC is enabled * @param trustAnchor Public cryptographic to validate against * @param server Server to use as DNS resolver * * @return <code>null</code> in case the <code>Resolver</code> cannot be instantiated */ private static Resolver instantiateResolver(boolean dnsSec, String trustAnchor, String server) { try { Resolver resolver = new SimpleResolver(server); if (!dnsSec) { return resolver; } ValidatingResolver validating = new ValidatingResolver(resolver); validating.loadTrustAnchors(new ByteArrayInputStream(trustAnchor.getBytes(StandardCharsets.UTF_8))); return validating; } catch (IOException e) { return null; } }
private void init() { if (mInitialized) return; else mInitialized = true; try { // configure the resolvers, starting with the default ones (based on the current network connection) Resolver defaultResolver = Lookup.getDefaultResolver(); // use Google's public DNS services Resolver googleFirstResolver = new SimpleResolver("8.8.8.8"); Resolver googleSecondResolver = new SimpleResolver("8.8.4.4"); // also try using Amazon Resolver amazonResolver = new SimpleResolver("205.251.198.30"); Lookup.setDefaultResolver(new ExtendedResolver(new Resolver[]{ googleFirstResolver, googleSecondResolver, amazonResolver, defaultResolver })); } catch (UnknownHostException e) { Log.w(TAG, "Couldn't initialize custom resolvers"); } }
@Test public void testDnsJavaWithDnsServer() throws TextParseException, UnknownHostException { final Lookup l = new Lookup("example.com", Type.AAAA); final SimpleResolver resolver = new SimpleResolver("::1"); resolver.setPort(9153); l.setResolver(resolver); l.run(); System.out.println("result: " + l.getResult()); final Record[] answers = l.getAnswers(); assertEquals(answers.length, 1); final Record record = answers[0]; System.err.println(record.getTTL()); if(l.getResult() == Lookup.SUCCESSFUL) { System.out.println(l.getAnswers()[0].rdataToString()); } assertTrue(l.getResult() == Lookup.SUCCESSFUL); }
@Test @JUnitDNSServer(port=9153, zones={}) public void testNoAnswer() throws Exception { final Lookup l = new Lookup("example.com", Type.AAAA); final SimpleResolver resolver = new SimpleResolver("::1"); resolver.setPort(9153); l.setResolver(resolver); l.run(); System.out.println("result: " + l.getResult()); final Record[] answers = l.getAnswers(); assertNotNull(answers); assertEquals(answers.length, 1); final Record record = answers[0]; System.err.println(record.getTTL()); if(l.getResult() == Lookup.SUCCESSFUL) { System.out.println(l.getAnswers()[0].rdataToString()); } assertTrue(l.getResult() == Lookup.SUCCESSFUL); }
@Test @JUnitDNSServer(port=9153, zones={}) public void testNoAnswer() throws Exception { final Lookup l = new Lookup("example.com", Type.AAAA); final SimpleResolver resolver = new SimpleResolver("::1"); resolver.setPort(9153); l.setResolver(resolver); l.run(); System.out.println("result: " + l.getResult()); final Record[] answers = l.getAnswers(); assertEquals(answers.length, 1); final Record record = answers[0]; System.err.println(record.getTTL()); if(l.getResult() == Lookup.SUCCESSFUL) { System.out.println(l.getAnswers()[0].rdataToString()); } assertTrue(l.getResult() == Lookup.SUCCESSFUL); }
public static Long getASN(final InetAddress adr) { try { final Name postfix; if (adr instanceof Inet6Address) postfix = Name.fromConstantString("origin6.asn.cymru.com"); else postfix = Name.fromConstantString("origin.asn.cymru.com"); final Name name = getReverseIPName(adr, postfix); System.out.println("lookup: " + name); final Lookup lookup = new Lookup(name, Type.TXT); lookup.setResolver(new SimpleResolver()); lookup.setCache(null); final Record[] records = lookup.run(); if (lookup.getResult() == Lookup.SUCCESSFUL) for (final Record record : records) if (record instanceof TXTRecord) { final TXTRecord txt = (TXTRecord) record; @SuppressWarnings("unchecked") final List<String> strings = txt.getStrings(); if (strings != null && !strings.isEmpty()) { final String result = strings.get(0); final String[] parts = result.split(" ?\\| ?"); if (parts != null && parts.length >= 1) return new Long(parts[0].split(" ")[0]); } } } catch (final Exception e) { } return null; }
public static String getASName(final long asn) { try { final Name postfix = Name.fromConstantString("asn.cymru.com."); final Name name = new Name(String.format("AS%d", asn), postfix); System.out.println("lookup: " + name); final Lookup lookup = new Lookup(name, Type.TXT); lookup.setResolver(new SimpleResolver()); lookup.setCache(null); final Record[] records = lookup.run(); if (lookup.getResult() == Lookup.SUCCESSFUL) for (final Record record : records) if (record instanceof TXTRecord) { final TXTRecord txt = (TXTRecord) record; @SuppressWarnings("unchecked") final List<String> strings = txt.getStrings(); if (strings != null && !strings.isEmpty()) { System.out.println(strings); final String result = strings.get(0); final String[] parts = result.split(" ?\\| ?"); if (parts != null && parts.length >= 1) return parts[4]; } } } catch (final Exception e) { } return null; }
public static String getAScountry(final long asn) { try { final Name postfix = Name.fromConstantString("asn.cymru.com."); final Name name = new Name(String.format("AS%d", asn), postfix); System.out.println("lookup: " + name); final Lookup lookup = new Lookup(name, Type.TXT); lookup.setResolver(new SimpleResolver()); lookup.setCache(null); final Record[] records = lookup.run(); if (lookup.getResult() == Lookup.SUCCESSFUL) for (final Record record : records) if (record instanceof TXTRecord) { final TXTRecord txt = (TXTRecord) record; @SuppressWarnings("unchecked") final List<String> strings = txt.getStrings(); if (strings != null && !strings.isEmpty()) { final String result = strings.get(0); final String[] parts = result.split(" ?\\| ?"); if (parts != null && parts.length >= 1) return parts[1]; } } } catch (final Exception e) { } return null; }
@Override public void process(Exchange exchange) throws Exception { String server = exchange.getIn().getHeader(DnsConstants.DNS_SERVER, String.class); SimpleResolver resolver = new SimpleResolver(server); int type = Type.value(exchange.getIn().getHeader(DnsConstants.DNS_TYPE, String.class)); if (type == -1) { // default: if unparsable value given, use A. type = Type.A; } String dclassValue = exchange.getIn().getHeader(DnsConstants.DNS_CLASS, String.class); if (dclassValue == null) { dclassValue = ""; } int dclass = DClass.value(dclassValue); if (dclass == -1) { // by default, value is IN. dclass = DClass.IN; } Name name = Name.fromString(exchange.getIn().getHeader(DnsConstants.DNS_NAME, String.class), Name.root); Record rec = Record.newRecord(name, type, dclass); Message query = Message.newQuery(rec); Message response = resolver.send(query); exchange.getIn().setBody(response); }
@Override public void process(Exchange exchange) throws Exception { SimpleResolver resolver = new SimpleResolver(); int type = Type.TXT; Name name = Name.fromString(String.valueOf(exchange.getIn().getHeader(DnsConstants.TERM)) + ".wp.dg.cx", Name.root); Record rec = Record.newRecord(name, type, DClass.IN); Message query = Message.newQuery(rec); Message response = resolver.send(query); Record[] records = response.getSectionArray(Section.ANSWER); if (records.length > 0) { exchange.getIn().setBody(records[0].rdataToString()); } else { exchange.getIn().setBody(null); } }
/** * resolves an SRV record by its name using a specified DNS host and port * * @param resolverHost name server hostname or IP address * @param resolverPort name server port * @param name the DNS name of the SRV record * @return a comma separate list of ip:port, e.g: 1.2.3.4:8080,2.3.4.5:9090 or null when unable to resolve */ public String resolveServiceByName(String resolverHost, int resolverPort, String name) { try { SimpleResolver resolver = new SimpleResolver(resolverHost); resolver.setPort(resolverPort); return resolveSrvByName(resolver, name); } catch (UnknownHostException e) { log.warn("unable to resolve using SRV record " + name, e); return null; } }
public static void main(String[] args) throws Exception { Lookup lookup = new Lookup("www.xqbase.com"); lookup.setResolver(new SimpleResolver("localhost")); lookup.run(); for (Record record : lookup.getAnswers()) { System.out.println(record); } }
private SimpleResolver getResolver() throws UnknownHostException { final String skyDnsAddress = getEnv("SKYDNS_SERVER", "localhost"); final SimpleResolver resolver = new SimpleResolver(skyDnsAddress); final String skyDnsPort = System.getenv("SKYDNS_PORT"); resolver.setPort(isNullOrEmpty(skyDnsPort) ? 53 : Integer.parseInt(skyDnsPort)); return resolver; }
private Lookup doLookup(final SimpleResolver resolver, String hostname) throws TextParseException { final Cache cache = new Cache(); final Lookup lookup = new Lookup(new Name(hostname), org.xbill.DNS.Type.SRV); lookup.setResolver(resolver); lookup.setCache(cache); return lookup; }
@Test public void canResolveRecord() throws Exception { AcceptanceTestRunner runner = new AcceptanceTestRunner(); runner.runUngarded(new AcceptanceScenario() { public void run(WebDriver driver, String deployedURL) throws Exception { int id = new SecureRandom().nextInt(); final String systemTestBase = "system-tests.onomate.test"; final String soaBase = "soa-" + id +"."+ systemTestBase; final String ns = "ns." + soaBase; final String contactName = "admin." + soaBase; final String aTestRecordHost = "record."+soaBase; final String aTestRecordNS = "ns.test"; OnomateAssembly assembly = new OnomateAssembly(driver, deployedURL); OnomateAssembly.Dashboard board = assembly.gotoLanding().authenticate().newAuthority(soaBase, ns, contactName); board.authorityByZone(soaBase).details().createRecord(aTestRecordHost, OnomateAssembly.RecordType.NS, aTestRecordNS); Options.set("verbose"); SimpleResolver resolver = new SimpleResolver(); resolver.setAddress(InetAddress.getLocalHost()); resolver.setPort(9101); Record query = Record.newRecord(Name.fromString(aTestRecordHost + "."), Type.NS, DClass.IN); Message question = Message.newQuery(query); Message response = resolver.send(question); Record responses[] = response.getSectionArray(Section.AUTHORITY); NSRecord record = ((NSRecord) responses[0]); assertEquals(record.getName().toString(), aTestRecordHost+ "."); assertEquals(record.getTarget().toString(), aTestRecordNS + "."); } }); }
@Test public void dnsServerRespondsWithAuthority() throws Exception { AcceptanceTestRunner runner = new AcceptanceTestRunner(); runner.runUngarded(new AcceptanceScenario() { public void run(WebDriver driver, String deployedURL) throws Exception { int id = new SecureRandom().nextInt(); final String systemTestBase = "system-tests.onomate.test"; final String soaBase = "soa-" + id + systemTestBase; final String ns = "ns." + soaBase; final String contactName = "admin." + soaBase; OnomateAssembly assembly = new OnomateAssembly(driver, deployedURL); OnomateAssembly.Dashboard board = assembly.gotoLanding().authenticate().newAuthority(soaBase, ns, contactName); board.authorityByZone(soaBase).waitOnPersisted(); Lookup lookup = new Lookup(soaBase, Type.SOA); SimpleResolver resolver = new SimpleResolver(); resolver.setAddress(InetAddress.getLocalHost()); resolver.setPort(9101); lookup.setResolver(resolver); lookup.setCache(null); Record[] results = lookup.run(); assertEquals(lookup.getResult(), Lookup.SUCCESSFUL, "Resolution Successful"); assertNotNull(results); assertEquals(results.length, 1); SOARecord record = ((SOARecord) results[0]); assertEquals(record.getAdmin().toString(), contactName + "."); assertEquals(record.getHost().toString(), ns + "."); assertEquals(record.getName().toString(), soaBase + "."); } }); }
@Test public void canResolveRecord() throws Exception { AcceptanceTestRunner runner = new AcceptanceTestRunner(); runner.runUngarded(new AcceptanceScenario() { public void run(WebDriver driver, String deployedURL) throws Exception { int id = new SecureRandom().nextInt(); final String systemTestBase = "system-tests.onomate.test"; final String soaBase = "soa-" + id +"."+ systemTestBase; final String ns = "ns." + soaBase; final String contactName = "admin." + soaBase; final String aTestRecordHost = "a-test-record."+soaBase; final String aTestRecordAddress = "127.0.0.100"; OnomateAssembly assembly = new OnomateAssembly(driver, deployedURL); OnomateAssembly.Dashboard board = assembly.gotoLanding().authenticate().newAuthority(soaBase, ns, contactName); board.authorityByZone(soaBase).details().createRecord(aTestRecordHost, RecordType.A, aTestRecordAddress); Lookup lookup = new Lookup(aTestRecordHost, Type.A); SimpleResolver resolver = new SimpleResolver(); resolver.setAddress(InetAddress.getLocalHost()); resolver.setPort(9101); lookup.setResolver(resolver); lookup.setCache(null); Record[] results = lookup.run(); assertEquals(lookup.getResult(), Lookup.SUCCESSFUL, "Resolution to be completed succesfully"); assertNotNull(results); assertEquals(results.length, 1); ARecord record = ((ARecord) results[0]); assertEquals(record.getName().toString(), aTestRecordHost+ "."); assertEquals(record.getAddress().getHostAddress(), aTestRecordAddress); } }); }
@Test public void canResolveRecord() throws Exception { AcceptanceTestRunner runner = new AcceptanceTestRunner(); runner.runUngarded(new AcceptanceScenario() { public void run(WebDriver driver, String deployedURL) throws Exception { int id = new SecureRandom().nextInt(); final String systemTestBase = "system-tests.onomate.test"; final String soaBase = "soa-" + id +"."+ systemTestBase; final String ns = "ns." + soaBase; final String contactName = "admin." + soaBase; final String aTestRecordHost = "record."+soaBase; final String aRealTestRecord = soaBase; OnomateAssembly assembly = new OnomateAssembly(driver, deployedURL); OnomateAssembly.Dashboard board = assembly.gotoLanding().authenticate().newAuthority(soaBase, ns, contactName); board.authorityByZone(soaBase).details().createRecord(aTestRecordHost, OnomateAssembly.RecordType.CNAME, aRealTestRecord); Options.set("verbose"); SimpleResolver resolver = new SimpleResolver(); resolver.setAddress(InetAddress.getLocalHost()); resolver.setPort(9101); Record query = Record.newRecord(Name.fromString(aTestRecordHost + "."), Type.CNAME, DClass.IN); Message question = Message.newQuery(query); Message response = resolver.send(question); Record responses[] = response.getSectionArray(Section.ANSWER); CNAMERecord record = ((CNAMERecord) responses[0]); assertEquals(record.getName().toString(), aTestRecordHost+ "."); assertEquals(record.getTarget().toString(), aRealTestRecord + "."); } }); }
@Test public void testDnsJavaResponse() throws IOException { final Lookup l = new Lookup("example.com"); final SimpleResolver resolver = new SimpleResolver("127.0.0.1"); resolver.setPort(9153); l.setResolver(resolver); l.run(); System.out.println("result: " + l.getResult()); if(l.getResult() == Lookup.SUCCESSFUL) { System.out.println(l.getAnswers()[0].rdataToString()); } assertTrue(l.getResult() == Lookup.SUCCESSFUL); }
@Test public void testDnsJavaQuadARecord() throws IOException { final Lookup l = new Lookup("ipv6.example.com", Type.AAAA); final SimpleResolver resolver = new SimpleResolver("::1"); resolver.setPort(9153); l.setResolver(resolver); l.run(); System.out.println("result: " + l.getResult()); if(l.getResult() == Lookup.SUCCESSFUL) { System.out.println(l.getAnswers()[0].rdataToString()); } assertTrue(l.getResult() == Lookup.SUCCESSFUL); }
@Before public void setup() throws NumberFormatException, IOException, DNSSECException { resolver = new ValidatingResolver(new SimpleResolver("62.192.5.131") { @Override public Message send(Message query) throws IOException { System.out.println("---" + key(query)); Message response = queryResponsePairs.get(key(query)); if (response != null) { return response; } else if ((offline && !partialOffline) || unboundTest || alwaysOffline) { Assert.fail("Response for " + key(query) + " not found."); } Message networkResult = super.send(query); if (record) { w.write(networkResult.toString()); w.write("\n\n###############################################\n\n"); } return networkResult; } }); resolver.loadTrustAnchors(getClass().getResourceAsStream("/trust_anchors")); System.err.println("--------------"); }
public static Record[] dig(String name) throws TextParseException, UnknownHostException { // logger.debug("Requesting DNS query for " + name + // " against localhost."); Lookup l = new Lookup(name); l.setResolver(new SimpleResolver("localhost")); Record[] records = l.run(); return records; }
public static Record[] dig(String name, String resolver) throws TextParseException, UnknownHostException { // logger.debug("Requesting DNS query for " + name + " against " + // resolver + "."); Lookup l = new Lookup(name); l.setResolver(new SimpleResolver(resolver)); Record[] records = l.run(); return records; }