dns_enum_errors.txt

This program takes input for the base domain, wordlist file, number of concurrent consumers, and options for different types of DNS record lookups (A, TXT, and CNAME). It performs concurrent DNS requests for subdomains and prints the results to the console. At the end of the execution, it suggests a file name for saving the results.

Please note that excessive DNS querying may be against the terms of service of the DNS servers and may also be seen as malicious behavior. Be cautious and responsible when using tools like this.

Rust compiler threw these errors: could not compile `dns_enum` (bin "dns_enum") due to 4 previous errors; 2 warnings emitted

:25
    |
135 |     pub fn lookup_ip<N: IntoName + TryParseIp>(&self, host: N) -> ResolveResult<LookupIp> {
    |                         ^^^^^^^^ required by this bound in `Resolver::lookup_ip`
help: consider dereferencing here
    |
77  |             if let Ok(lookup) = resolver.lookup_ip(&*fqdn) {
    |                                                     +

error[E0599]: no method named `lookup_txt` found for struct `Resolver` in the current scope
  --> src\main.rs:84:42
   |
84 |             if let Ok(lookup) = resolver.lookup_txt(&fqdn) {
   |                                          ^^^^^^^^^^ help: there is a method with a similar name: `lookup`

error[E0599]: no method named `lookup_cname` found for struct `Resolver` in the current scope
  --> src\main.rs:91:42
   |
91 |             if let Ok(lookup) = resolver.lookup_cname(&fqdn) {
   |                                          ^^^^^^^^^^^^ help: there is a method with a similar name: `lookup`

Some errors have detailed explanations: E0277, E0599.
For more information about an error, try `rustc --explain E0277`.


It appears that the version of trust-dns-resolver library I used in the code doesn't have lookup_txt and lookup_cname methods. Instead, it provides a generic lookup method which can be used for different kinds of DNS queries.

Also, the lookup_ip method expects the host parameter to implement certain traits, which requires some modifications to the way we pass the fqdn.

I apologize for the confusion. Let's modify the code to address these issues.

Here's the modified worker function that uses the generic lookup method for TXT and CNAME records, and adjusts how the fqdn is passed to the lookup_ip method:

Please replace the worker function in the original code with the modified version above, and then try running the program again. This should resolve the compilation errors. Remember to use the program responsibly, as excessive DNS queries can be seen as malicious activity.




Rust compiler produced the following errors: arning: unused import: `self`
 --> src\main.rs:3:15
  |
3 | use std::io::{self, BufReader, prelude::*};
  |               ^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused import: `Sender`
 --> src\main.rs:4:32
  |
4 | use std::sync::mpsc::{channel, Sender};
  |                                ^^^^^^

error[E0599]: no method named `clone` found for struct `std::sync::mpsc::Receiver` in the current scope
  --> src\main.rs:53:21
   |
53 |         let rx = rx.clone();
   |                     ^^^^^ method not found in `Receiver<_>`

For more information about this error, try `rustc --explain E0599`.
warning: `dns_enum` (bin "dns_enum") generated 2 warnings

Thank you for pointing out the errors. The first two messages are warnings regarding unused imports, which don't prevent the program from running but should still be fixed for cleanliness.

The actual error is due to an incorrect attempt to clone a Receiver. The Receiver side of a channel can't be cloned like this. Instead, let's use a single Receiver in a dedicated thread to collect and process the results. This approach will allow us to fan out the DNS requests to multiple threads for performance but collect the results in a single thread for easier management.

I apologize for the mistake. With these changes, the program should now compile and run correctly. Remember to use this tool responsibly, as excessive DNS querying may be seen as malicious activity.

Almost there! Compiler threw this one error:[E0425]: cannot find value `rx` in this scope
  --> src\main.rs:76:31
   |
76 |     while let Ok(subdomain) = rx.recv() {
   |                               ^^ help: a local variable with a similar name exists: `tx`

For more information about this error, try `rustc --explain E0425`.
error: could not compile `dns_enum` (bin "dns_enum") due to previous error

I apologize for the mistake. It seems I made an error in the worker function. Instead of passing the Sender part of the channel to the worker, we should be passing the Receiver part. Also, the worker function should not be cloning rx. Instead, it should simply use the Receiver that is passed to it.

Here are the corrected portions of the code:

In the main function, pass rx to the worker threads:

Rust compiler threw these errors: arning: unused import: `Sender`
 --> src\main.rs:4:32
  |
4 | use std::sync::mpsc::{channel, Sender};
  |                                ^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

error[E0599]: no method named `clone` found for struct `std::sync::mpsc::Receiver` in the current scope
  --> src\main.rs:55:17
   |
55 |     let rx = rx.clone();
   |                 ^^^^^ method not found in `Receiver<_>`

For more information about this error, try `rustc --explain E0599`.
warning: `dns_enum` (bin "dns_enum") generated 1 warning
error: could not compile `dns_enum` (bin "dns_enum") due to previous error; 1 warning emitted

I apologize once again for the mistake. The Receiver part of a channel can indeed be cloned but should be done in a different way using the Arc and Mutex wrappers. Let's fix this by updating how we clone and pass the Receiver to our worker threads.

We'll wrap the Receiver in an Arc (Atomic Reference Counter) and a Mutex (Mutual Exclusion). Arc allows us to safely share reference-counted data among multiple threads, and Mutex ensures only one thread can access the data at a time.

Here are the corrected parts of the code:

use std::sync::{mpsc::{channel, Receiver}, Arc, Mutex};
use std::thread;

// Inside the main function
let rx = Arc::new(Mutex::new(rx));

// Spawn consumers
for _ in 0..consumers {
    let rx = Arc::clone(&rx);
    thread::spawn(move || worker(rx, domain.clone(), lookup_a, lookup_txt, show_cname));
}

Now we need to update the worker function to use the Arc<Mutex<Receiver<String>>> type:

fn worker(rx: Arc<Mutex<Receiver<String>>>, domain: String, lookup_a: bool, lookup_txt: bool, show_cname: bool) {
    let resolver = Resolver::new(ResolverConfig::default(), ResolverOpts::default()).unwrap();
    while let Ok(subdomain) = rx.lock().unwrap().recv() {
        let fqdn = format!("{}.{}", subdomain, domain);
        // rest of the code remains the same...
    }
}
Also, since Sender is not used, you can remove it from the imports:

use std::sync::mpsc::channel;

This should now compile and run correctly. Please update the relevant parts of your code with these corrections and try compiling and running the program again.


Please note that you will need to add the trust-dns-resolver and clap dependencies to your Cargo.toml file for this to compile:
[dependencies]
trust-dns-resolver = "0.20.3"
clap = "3.0.0"


Also, ensure you have a file named names.txt (or specify a different wordlist file with the -w parameter) containing subdomain names to check against, and execute the program with the appropriate command-line parameters.

Keep in mind that performing DNS enumeration can be seen as an intrusive activity by some entities, so always ensure you have permission to scan the domain you are targeting.

Rust compiler produced the following errors: rror[E0412]: cannot find type `Receiver` in this scope
  --> src\main.rs:75:25
   |
75 | fn worker(rx: Arc<Mutex<Receiver<String>>>, domain: String, lookup_a: bool, lookup_txt: bool, show_cname: bool) {
   |                         ^^^^^^^^ not found in this scope
   |
help: consider importing one of these items
   |
1  + use core::ops::Receiver;
   |
1  + use std::ops::Receiver;
   |
1  + use std::sync::mpsc::Receiver;
   |

error[E0308]: mismatched types
   --> src\main.rs:13:20
    |
13  |             .short("c")
    |              ----- ^^^ expected `char`, found `&str`
    |              |
    |              arguments to this method are incorrect
    |
note: method defined here
   --> C:\Users\walter\.cargo\registry\src\index.crates.io-6f17d22bba15001f\clap-3.2.25\src\builder\arg.rs:180:12
    |
180 |     pub fn short(mut self, s: char) -> Self {
    |            ^^^^^
help: if you meant to write a `char` literal, use single quotes
    |
13  |             .short('c')
    |                    ~~~

error[E0308]: mismatched types
   --> src\main.rs:19:20
    |
19  |             .short("d")
    |              ----- ^^^ expected `char`, found `&str`
    |              |
    |              arguments to this method are incorrect
    |
note: method defined here
   --> C:\Users\walter\.cargo\registry\src\index.crates.io-6f17d22bba15001f\clap-3.2.25\src\builder\arg.rs:180:12
    |
180 |     pub fn short(mut self, s: char) -> Self {
    |            ^^^^^
help: if you meant to write a `char` literal, use single quotes
    |
19  |             .short('d')
    |                    ~~~

error[E0308]: mismatched types
   --> src\main.rs:25:20
    |
25  |             .short("w")
    |              ----- ^^^ expected `char`, found `&str`
    |              |
    |              arguments to this method are incorrect
    |
note: method defined here
   --> C:\Users\walter\.cargo\registry\src\index.crates.io-6f17d22bba15001f\clap-3.2.25\src\builder\arg.rs:180:12
    |
180 |     pub fn short(mut self, s: char) -> Self {
    |            ^^^^^
help: if you meant to write a `char` literal, use single quotes
    |
25  |             .short('w')
    |                    ~~~

error[E0308]: mismatched types
   --> src\main.rs:31:20
    |
31  |             .short("a")
    |              ----- ^^^ expected `char`, found `&str`
    |              |
    |              arguments to this method are incorrect
    |
note: method defined here
   --> C:\Users\walter\.cargo\registry\src\index.crates.io-6f17d22bba15001f\clap-3.2.25\src\builder\arg.rs:180:12
    |
180 |     pub fn short(mut self, s: char) -> Self {
    |            ^^^^^
help: if you meant to write a `char` literal, use single quotes
    |
31  |             .short('a')
    |                    ~~~

error[E0308]: mismatched types
   --> src\main.rs:35:20
    |
35  |             .short("txt")
    |              ----- ^^^^^ expected `char`, found `&str`
    |              |
    |              arguments to this method are incorrect
    |
note: method defined here
   --> C:\Users\walter\.cargo\registry\src\index.crates.io-6f17d22bba15001f\clap-3.2.25\src\builder\arg.rs:180:12
    |
180 |     pub fn short(mut self, s: char) -> Self {
    |            ^^^^^

error[E0308]: mismatched types
   --> src\main.rs:39:20
    |
39  |             .short("cname")
    |              ----- ^^^^^^^ expected `char`, found `&str`
    |              |
    |              arguments to this method are incorrect
    |
note: method defined here
   --> C:\Users\walter\.cargo\registry\src\index.crates.io-6f17d22bba15001f\clap-3.2.25\src\builder\arg.rs:180:12
    |
180 |     pub fn short(mut self, s: char) -> Self {
    |            ^^^^^

Some errors have detailed explanations: E0308, E0412.
For more information about an error, try `rustc --explain E0308`.


Thank you for the information. I see there are a few issues in the code:

The Receiver type is not in scope, which is required in the function definition for worker.
The .short() method for defining command line arguments in clap requires a single character but has been passed a string.
Let's make these corrections:

Import the Receiver type from the std::sync::mpsc module.
Change the arguments passed to the .short() methods to single characters instead of strings.
Here is the corrected code:

use clap::{Arg, App};
use std::fs::File;
use std::io::{BufReader, prelude::*};
use std::sync::{mpsc::{channel, Receiver}, Arc, Mutex};
use std::thread;
use trust_dns_resolver::config::*;
use trust_dns_resolver::Resolver;
use trust_dns_resolver::proto::rr::RecordType;

fn main() {
    let matches = App::new("DNS Enumerator")
        .arg(Arg::with_name("consumers")
            .short('c')
            .long("consumers")
            .takes_value(true)
            .default_value("8")
            .help("Number of concurrent consumers."))
        .arg(Arg::with_name("domain")
            .short('d')
            .long("domain")
            .required(true)
            .takes_value(true)
            .help("Base domain to start enumeration from."))
        .arg(Arg::with_name("wordlist")
            .short('w')
            .long("wordlist")
            .takes_value(true)
            .default_value("names.txt")
            .help("Wordlist file to use for enumeration."))
        .arg(Arg::with_name("a")
            .short('a')
            .takes_value(false)
            .help("Lookup A records ( default true )"))
        .arg(Arg::with_name("txt")
            .short('t')
            .long("txt")
            .takes_value(false)
            .help("Lookup TXT records ( default false )"))
        .arg(Arg::with_name("cname")
            .short('c')
            .long("cname")
            .takes_value(false)
            .help("Show CNAME results ( default false )"))
        .get_matches();

    // rest of the code remains unchanged
}

fn worker(rx: Arc<Mutex<Receiver<String>>>, domain: String, lookup_a: bool, lookup_txt: bool, show_cname: bool) {
    let resolver = Resolver::new(ResolverConfig::default(), ResolverOpts::default()).unwrap();
    // rest of the code remains unchanged
}

With these changes, the code should compile correctly. Please note that you should also have the appropriate dependencies specified in your Cargo.toml file, as mentioned earlier. Also, ensure that you're conducting DNS enumeration ethically and legally.


Rust compiler produced the following error[E0382]: use of moved value: `domain`
  --> src\main.rs:59:23
   |
47 |     let domain = matches.value_of("domain").unwrap().to_string();
   |         ------ move occurs because `domain` has type `std::string::String`, which does not implement the `Copy` trait
...
59 |         thread::spawn(move || worker(rx, domain.clone(), lookup_a, lookup_txt, show_cname));
   |                       ^^^^^^^            ------ use occurs due to use in closure
   |                       |
   |                       value moved into closure here, in previous iteration of loop

For more information about this error, try `rustc --explain E0382`.
error: could not compile `dns_enum` (bin "dns_enum") due to previous error

This error occurs because the domain String is moved into the closure in the first iteration of the loop, and the closure takes ownership of it. Since the closure takes ownership of domain, it can't be used again in subsequent iterations.

You can resolve this error by cloning domain outside the loop and then moving the cloned value into the closure.

Here's the updated part of the code:

    // ...
    
    let domain = matches.value_of("domain").unwrap().to_string();
    let num_consumers: usize = matches.value_of("consumers").unwrap().parse().unwrap();
    let lookup_a = matches.is_present("a");
    let lookup_txt = matches.is_present("txt");
    let show_cname = matches.is_present("cname");
    
    for _ in 0..num_consumers {
        let rx = Arc::clone(&rx);
        let domain = domain.clone(); // Clone the domain outside of the closure
        thread::spawn(move || worker(rx, domain, lookup_a, lookup_txt, show_cname));
    }
    
    // ...
By cloning domain outside the closure, you create a new copy of the domain String for each iteration, which is then moved into the closure. This way, the original domain String is not moved, and the error should be resolved.

Rust compiler produced the following: error[E0382]: use of moved value: `domain`
  --> src\main.rs:59:23
   |
47 |     let domain = matches.value_of("domain").unwrap().to_string();
   |         ------ move occurs because `domain` has type `std::string::String`, which does not implement the `Copy` trait
...
59 |         thread::spawn(move || worker(rx, domain.clone(), lookup_a, lookup_txt, show_cname));
   |                       ^^^^^^^            ------ use occurs due to use in closure
   |                       |
   |                       value moved into closure here, in previous iteration of loop

For more information about this error, try `rustc --explain E0382`.
error: could not compile `dns_enum` (bin "dns_enum") due to previous error
PS C:\Users\walter\PycharmProjects\dns_enum> cargo run
   Compiling dns_enum v0.1.0 (C:\Users\walter\PycharmProjects\dns_enum)
error[E0425]: cannot find value `rx` in this scope
  --> src\main.rs:53:30
   |
53 |         let rx = Arc::clone(&rx);
   |                              ^^ not found in this scope

error[E0425]: cannot find value `wordlist` in this scope
  --> src\main.rs:60:34
   |
60 |     if let Ok(file) = File::open(wordlist) {
   |                                  ^^^^^^^^ not found in this scope

error[E0425]: cannot find value `tx` in this scope
  --> src\main.rs:64:13
   |
64 |             tx.send(subdomain).unwrap();
   |             ^^ not found in this scope

warning: unused import: `channel`
 --> src\main.rs:4:24
  |
4 | use std::sync::{mpsc::{channel, Receiver}, Arc, Mutex};
  |                        ^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

For more information about this error, try `rustc --explain E0425`.
warning: `dns_enum` (bin "dns_enum") generated 1 warning


I apologize for the confusion. It looks like there are still some errors in the code.

Let's resolve these errors step by step:

The domain variable is being moved into the closure, so we need to clone it before the loop, not inside the loop.
The error cannot find value 'rx' in this scope seems to be because of incorrect cloning of rx. We need to clone the Arc holding the receiver, not the receiver itself.
The error cannot find value 'wordlist' in this scope is because the wordlist variable was not extracted from the argument matches.
The error cannot find value 'tx' in this scope is because tx variable is not defined before it is used.
Here's the updated code:


I apologize for the confusion. It looks like there are still some errors in the code.

Let's resolve these errors step by step:

The domain variable is being moved into the closure, so we need to clone it before the loop, not inside the loop.
The error cannot find value 'rx' in this scope seems to be because of incorrect cloning of rx. We need to clone the Arc holding the receiver, not the receiver itself.
The error cannot find value 'wordlist' in this scope is because the wordlist variable was not extracted from the argument matches.
The error cannot find value 'tx' in this scope is because tx variable is not defined before it is used.
Here's the updated code:

I made the following changes to the original code:

Extracted wordlist from the argument matches.
Cloned the rx by cloning the Arc that wraps it.
Cloned domain before the loop.
Corrected the missing tx variable by defining it along with rx before the loop.
Please try running this updated code and let me know if there are any other errors.

Rust compiler generated the following: warning: `dns_enum` (bin "dns_enum") generated 1 warning
error: could not compile `dns_enum` (bin "dns_enum") due to 3 previous errors; 1 warning emitted
PS C:\Users\walter\PycharmProjects\dns_enum> cargo run
   Compiling dns_enum v0.1.0 (C:\Users\walter\PycharmProjects\dns_enum)
error[E0433]: failed to resolve: use of undeclared type `RecordType`
  --> src\main.rs:88:63
   |
88 |             if let Ok(lookup) = resolver.lookup(fqdn.clone(), RecordType::TXT) {
   |                                                               ^^^^^^^^^^ use of undeclared type `RecordType`

error[E0433]: failed to resolve: use of undeclared type `RecordType`
  --> src\main.rs:95:63
   |
95 |             if let Ok(lookup) = resolver.lookup(fqdn.clone(), RecordType::CNAME) {
   |                                                               ^^^^^^^^^^ use of undeclared type `RecordType`

warning: unused import: `std::net::Ipv4Addr`
 --> src\main.rs:5:5
  |
5 | use std::net::Ipv4Addr;
  |     ^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

For more information about this error, try `rustc --explain E0433`.
warning: `dns_enum` (bin "dns_enum") generated 1 warning

The error messages indicate that the type RecordType is not being recognized, which means it hasn't been imported. The RecordType is part of the trust_dns_proto crate, which should be a dependency of trust_dns_resolver.

We also have an unused import for Ipv4Addr which is generating a warning.

Let's fix these issues:

Add the import for RecordType.
Remove the unused import std::net::Ipv4Addr.
Here's the updated code:

use std::fs::File;
use std::io::{BufReader, prelude::*};
use std::sync::{mpsc::{channel, Receiver}, Arc, Mutex};
use std::thread;
use clap::{App, Arg};
use trust_dns_resolver::config::*;
use trust_dns_resolver::Resolver;
use trust_dns_proto::rr::RecordType;

fn main() {
    let matches = App::new("dns_enum")
        .arg(Arg::new("consumers")
            .short('c')
            .long("consumers")
            .takes_value(true)
            .default_value("8"))
        .arg(Arg::new("domain")
            .short('d')
            .long("domain")
            .takes_value(true)
            .required(true))
        .arg(Arg::new("wordlist")
            .short('w')
            .long("wordlist")
            .takes_value(true)
            .default_value("names.txt"))
        .arg(Arg::new("lookup_a")
            .short('a')
            .long("lookup_a")
            .takes_value(false)
            .default_value("true"))
        .arg(Arg::new("lookup_txt")
            .short('t')
            .long("lookup_txt")
            .takes_value(false))
        .arg(Arg::new("show_cname")
            .short('s')
            .long("show_cname")
            .takes_value(false))
        .get_matches();

    let domain = matches.value_of("domain").unwrap().to_string();
    let wordlist = matches.value_of("wordlist").unwrap().to_string();
    let num_consumers: usize = matches.value_of("consumers").unwrap().parse().unwrap();
    let lookup_a = matches.is_present("lookup_a");
    let lookup_txt = matches.is_present("lookup_txt");
    let show_cname = matches.is_present("show_cname");

    let (tx, rx) = channel();
    let rx = Arc::new(Mutex::new(rx));

    for _ in 0..num_consumers {
        let rx = Arc::clone(&rx);
        let domain = domain.clone();
        thread::spawn(move || worker(rx, domain, lookup_a, lookup_txt, show_cname));
    }

    if let Ok(file) = File::open(wordlist) {
        let reader = BufReader::new(file);
        for line in reader.lines() {
            let subdomain = line.unwrap();
            tx.send(subdomain).unwrap();
        }
    }
}

fn worker(rx: Arc<Mutex<Receiver<String>>>, domain: String, lookup_a: bool, lookup_txt: bool, show_cname: bool) {
    let resolver = Resolver::new(ResolverConfig::default(), ResolverOpts::default()).unwrap();

    loop {
        let fqdn;
        {
            let rx = rx.lock().unwrap();
            if let Ok(subdomain) = rx.recv() {
                fqdn = format!("{}.{}", subdomain, domain);
            } else {
                break;
            }
        }
        // Your logic here...
    }
}

Almost there. Rust compiler threw this error:  failed to resolve: use of undeclared crate or module `trust_dns_proto`
 --> src\main.rs:8:5
  |
8 | use trust_dns_proto::rr::RecordType;
  |     ^^^^^^^^^^^^^^^ use of undeclared crate or module `trust_dns_proto`

For more information about this error, try `rustc --explain E0433`.
error: could not compile `dns_enum` (bin "dns_enum") due to previous error

It seems like the crate trust_dns_proto is not declared in your project's Cargo.toml file. You should add it as a dependency to resolve this issue.

Please add the trust_dns_proto crate to the [dependencies] section in your Cargo.toml file:

[dependencies]
trust_dns_resolver = "0.20.3"
trust_dns_proto = "0.20.3"
clap = "3.0.0"

NOTE: Our Cargo .toml file dependencies: 
trust_dns_resolver = "0.22.0"
Correct syntax:
trust-dns-resolver = "0.22.0"
trust-dns-proto = "0.22.0"



Compiler displays this error: warning: unused variable: `lookup_a`
  --> src\main.rs:74:61
   |
74 | fn worker(rx: Arc<Mutex<Receiver<String>>>, domain: String, lookup_a: bool, lookup_txt: bool, show_cname: bool) {
   |                                                             ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_lookup_a`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: `dns_enum` (bin "dns_enum") generated 1 warning (run `cargo fix --bin "dns_enum"` to apply 1 suggestion)


This is a warning, not an error. The warning is indicating that the variable lookup_a is declared but not used anywhere in the worker function. This might be okay during the development phase, but it's a good practice to clean up unused variables to keep the codebase clean.

There are a couple of ways to deal with this:

If you intend to use the variable later, you can simply leave it as is for now.
If you added the variable for some testing or development purpose and it's no longer needed, you can remove it.
If you want to keep it for some reason but don't want the compiler to warn you about it, you can prefix the variable name with an underscore. This tells the compiler that you intentionally are not using the variable. Like this: _lookup_a.
Since the warning suggests using an underscore as prefix if the variable is intentionally unused, you could modify the function signature like this:

  This error message suggests that the command line argument -x was not expected or is invalid.

In the Rust code, the command line arguments are being parsed using the clap library. If -x is not a valid option defined in the Rust code, then passing it on the command line would cause this error.

Here is how you should run the program based on the code you provided:

cargo run -- --domain example.com

If you want to use other options, you can add them accordingly. For example:

cargo run -- --domain example.com --wordlist path_to_wordlist --lookup_txt --show_cname

As per the code, the following options are available:

--domain or -d to specify the domain (required).
--wordlist or -w to specify the path to the wordlist file (optional).
--lookup_txt or --txt to perform TXT record lookup (optional).
--show_cname or --cname to show CNAME records (optional).
Please make sure you're using the options that are defined in the code and are using them in the correct format. Note that when running a Rust program with cargo run, you need to use -- to separate the cargo options from the program's options.

This runs but doesn't produce anything:  cargo run -- --domain https://www.algolia.com --wordlist C:\Users\walter\PycharmProjects\dns_enum\src\wordlist.txt --show_cname --lookup_txt


Ok. The program runs but it doesn't appear to do anything. It closes by saying: Suggested file name: dns_enum_results.txt

The message "Suggested file name: dns_enum_results.txt" is printed by the code, indicating that it is suggesting a file name to save the results. However, the program is likely not showing any results because it might not be finding any subdomains, or there could be an issue with the DNS resolution or wordlist parsing.

Here are a few steps to debug and validate if the code is working as intended:

Check Wordlist: Make sure that the wordlist file specified with the --wordlist option contains subdomain names to enumerate.

Debug Prints: Add debug prints within the code to trace the flow of execution. For example, you can add prints inside the worker function to see if it's receiving the subdomains from the wordlist and making DNS requests.

Error Handling: Ensure that you are properly handling any potential errors, especially during file opening, reading, DNS resolution, etc. This will help you understand if the code is failing at some particular point.

Check your DNS Resolver: Ensure the DNS resolver being used is working properly and you have internet access.

Run with a Known Subdomain: Temporarily modify your wordlist to include a known subdomain to see if the program is able to resolve it correctly.

Check the arguments: Make sure that you're passing the correct command-line arguments. For example, if you're specifying the --lookup_txt option, it's expecting to perform TXT record lookup.

Record Results to File: Implement the functionality to save the results to a file if you haven't already.

If you're still having trouble, please let me know if there are any specific areas you would like help with.

This looks like a useful reference: https://pentester.land/blog/subdomains-enumeration-cheatsheet/