You can save time by rotating the powers of ten to the right instead of rotating the digits to the left:

(toNumber = Table[RotateRight[10^Range[5, 0, -1], k - 3], {k, 3, 8}]; 
 digits = Tuples[{1, 2, 3, 4, 5, 6, 7, 8, 9}, 6]; 
 pick = Mod[toNumber . Transpose@digits, {7, 9, 11, 13, 15, 17}]; 
 Pick[digits, Total[pick], 0]) // AbsoluteTiming
(*
{0.024831, 
 {{5, 3, 1, 5, 3, 1}, {5, 9, 4, 5, 9, 4}}}
*)

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)}
*)

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