Hcfyk

We know that the longest common substring of two strings can be found in $mathcal O(N^2)$ time complexity.
Can a solution be found in only linear time?

Let $m$ and $n$ be the lengths of two given strings,

Linear time assuming the size of the alphabet is constant.

Yes, the longest common substring of two given strings can be found in $O(m+n)$ time, assuming the size of the alphabet is constant.

Here is an excerpt from Wikipedia article on longest common substring problem.

The longest common substrings of a set of strings can be found by building a generalized suffix tree for the strings, and then finding the deepest internal nodes which have leaf nodes from all the strings in the subtree below it.

Building a generalized suffix tree for two given strings takes $O(m+n)$ time using the famous ingenious Ukkonen's algorithm. Finding the deepest internal nodes that come from both strings takes $O(m+n)$ time. Hence we can find the longest common substring in $O(m+n)$ time.

For a working implementation, please take a look at Suffix Tree Application 5 – Longest Common Substring at GeeksforGeeks

(Improved!) Linear time

In fact, the longest common substring of two given strings can be found in $O(m+n)$ time regardless of the size of the alphabet.

Here is the abstract of Computing Longest Common Substrings Via Suffix Arrays by Babenko, Maxim & Starikovskaya, Tatiana. (2008).

Given a set of $N$ strings $A = {alpha_1,cdots,alpha_N}$ of total length $n$ over alphabet $Sigma$ one may ask to find, for each $2 le kle N$, the longest substring $beta$ that appears in at least $K$ strings in $A$. It is known that this problem can be solved in $O(n)$ time with the help of suffix trees. However, the resulting algorithm is rather complicated (in particular, it involves answering certain least common ancestor queries in $O(1)$ time). Also, its running time and memory consumption may depend on $|Sigma|$.

This paper presents an alternative, remarkably simple approach to
the above problem, which relies on the notion of suffix arrays. Once
the suffix array of some auxiliary $O(n)$-length string is computed, one
needs a simple $O(n)$-time postprocessing to find the requested longest
substring. Since a number of efficient and simple linear-time algorithms
for constructing suffix arrays has been recently developed (with constant
not depending on $|Sigma|$), our approach seems to be quite practical.

Here is the general idea of the algorithm in the paper above. Let string $alpha$ be concatenation of all $alpha_i$ with separating sentinels. Construct the suffix array for $α$ as well as its longest-common-prefix array. Apply a sliding window technique to these arrays to obtain the longest common substrings.

Yes. There's even a Wikipedia article about it! https://en.wikipedia.org/wiki/Longest_common_substring_problem

In particular, as Wikipedia explains, there is a linear-time algorithm, using suffix trees (or suffix arrays).

Searching on "longest common substring" turns up that Wikipedia article as the first hit (for me). In the future, please research the problem before asking here. (See, e.g., https://meta.stackoverflow.com/q/261592/781723.)