Bill's answer is much faster, but here is a way to use Reduce[] on such problems. The option "ExhaustiveSearchMaxPoints" is discussed in https://reference.wolfram.com/language/tutorial/DiophantineReduce.html.

Clear[a, b, d, c, d, e, f];
m[a1_, a2_, a3_, a4_, a5_, a6_] = 
  a1 10^5 + a2 10^4 + a3 10^3 + a4 10^2 + a5 10 + a6;

Reduce[{
   Mod[m[a, b, c, d, e, f], 7] == 0, 
   Mod[m[b, c, d, e, f, a], 9] == 0, 
   Mod[m[c, d, e, f, a, b], 11] == 0, 
   Mod[m[d, e, f, a, b, c], 13] == 0, 
   Mod[m[e, f, a, b, c, d], 15] == 0, 
   Mod[m[f, a, b, c, d, e], 17] == 0
   , And @@ Thread[1 <= {a, b, c, d, e, f} <= 9]}, 
  {a, b, d, c, d, e, f}, Integers,
  Method -> 
   {"ExhaustiveSearchMaxPoints" -> {9^6 + 1, 1000000}}
 ] // AbsoluteTiming
(*
{4.69601,
  (a == 5 && b == 3 && c == 1 && d == 5 && e == 3 && f == 1) || 
  (a == 5 && b == 9 && c == 4 && d == 5 && e == 9 && f == 4)}
*)

This is a bit indirect but quite fast. First set it up as a linear algebra problem. ``` m[ll : {a1, a2, a3, a4, a5, a6}] := ll . 10^Range[Length[ll] - 1, 0, -1] mods = {7, 9, 11, 13, 15, 17}; vars = {a, b, c, d, e, f}; {rhs, mat} = Normal@CoefficientArrays[Map[m, NestList[RotateLeft, vars, 5]], vars]

(* Out[69]= {{0, 0, 0, 0, 0, 0}, {{100000, 10000, 1000, 100, 10, 1}, {1, 100000, 10000, 1000, 100, 10}, {10, 1, 100000, 10000, 1000, 100}, {100, 10, 1, 100000, 10000, 1000}, {1000, 100, 10, 1, 100000, 10000}, {10000, 1000, 100, 10, 1, 100000}}}*) Now solve over the integers taking into account the moduli. Since the rhs is all zeros it is really the null vectors that are of interest. I use a setting for the appropriate WFR function to obtain those null vectors. This is followed with `LatticeReduce` to make the integers reasonably small. Timing[{sol, nulls} =ResourceFunction["LinearSolveMod"][mat, rhs, mods, True]; rednulls = LatticeReduce[nulls]]

(* Out[70]= {0.004999, {{-5, 3, 1, 5, 3, 2}, {-5, 3, 2, -5, 3, 2}, {-5, -3, -2, 5, -3, -1}, {1, -4, 3, 0, 6, 3}, {0, -1, 10, 0, 0, 0}, {-1, 1, 0, 0, -11, 20}}} *) Now we take integer combinations of the nulls and use `Solve` over the integers to obtain all sets where the resulting values are between 1 and 9 inclusive. newvars = Array[t, Length[rednulls]]; newvals = newvars . rednulls; Timing[solns = Solve[Map[1 <= # <= 9 &, newvals], newvars, Integers]; newvals /. solns]

(* Out[73]= {0.023115, {{5, 3, 1, 5, 3, 1}, {5, 9, 4, 5, 9, 4}}} *) `` An advantage to this roundabout approach is that we can avoid a brute-force method (to the extent that integer linear programming does so) and also make the task ofReduce` easier by first getting inputs to be small using lattice reduction.

The previous code might have some problems. I've fixed it now.