Grime, 20 bytes

n`.\1./\3.\4/.\2.voO 

Try it online!

A very literal implementation of the spec:

• n` make Grime count the number of subrectangles of the input that yield a match.

• .\1./\3.\4/.\2. defines the 3x3 square:

  .1. 3.4 .2. 

  Where . can be any character.

• oO is an orientation modifier which allows this rectangle to appear in any rotation or reflection. The v is used to lower os precedence so that we don't need parentheses around the square.

Snails, 17 16 bytes

Ao \1.=\2o=\3b\4 

Try it online!

Explanation

A makes Snails count the number of possible matching paths in the entire input. o sets the starting direction to any orthogonal direction (instead of just eastward). The pattern itself is on the second line:

\1 Match a 1. . Match an arbitrary character (the one in the centre). =\2 Check that the next character ahead is a 2, but don't move there. o Turn to any orthogonal direction. In practice, this will only be one of the two directions from the centre we haven't checked yet. =\3 Check that the next character ahead is a 3. b Turn around 180 degrees. \4 Match a 4 in that direction. 

Haskell, 108 102 93 bytes

f((_:t:x):w@((l:q@(_:r:_)):(_:b:z):_))=sum$f((t:x):q:[b:z]):f w:[1|(l*r-1)*(t*b-1)==11] f _=0 

Try it online!

No regex. Pattern match

.t. l.r .b. 

in the top left corner of the matrix , take a 1 if (l*r-1)*(t*b-1)==11 and recursively go to the right (drop .l.) and down (drop first row). If the pattern cannot be matched (at the right or bottom border) take a 0. Sum all results.

Edit: -9 bytes thanks to @xnor.

Perl, 70 bytes

Includes +2 for 0p

Give input matrix as a block of digits without spaces on STDIN:

perl -0pe '$_=map{/.$/m+y/1-4/3421/;/(?=1.{@{-}}(3.4|4.3).{@{-}}2)/sg}($_)x4' 0420 1324 2310 ^D 

Rotates the cross by rotating the digits

Retina, 92 83 82 bytes

L$v`(?<=(.)*).(.)..*¶(?<6-1>.)*(.).(.).*¶(?<-6>.)*.(.) $5$2$3$4 /../_O`. 1234|3412 

Try it online! Explanation:

L$v`(?<=(.)*).(.)..*¶(?<6-1>.)*(.).(.).*¶(?<-6>.)*.(.) $5$2$3$4 

Look for all overlapping 3x3 squares. A lookbehind captures the indent so that it can be balanced on the second line, itself transferring the indent from group 1 to group 6, so it can be balanced again on the third line. The input is assumed to be rectangular so we don't have to check that the groups balance. The bottom/top middle cells and the left/right middle cells are then captured.

/../_O`. 

Sort each pair of cells into order.

1234|3412 

Count the remaining valid patterns.

Jelly, 26 bytes

Z3Ƥṡ€3ẎµFḊm2ṙ-s2Ṣ€ṢFµ€ċ4R¤ 

Try it online!

Explanation

Z3Ƥṡ€3ẎµFḊm2ṙ-s2Ṣ€ṢFµ€ċ4R¤ Main Link 3Ƥ For each 3 rows Z Zip the rows ṡ€3 Get all arrangements of 3 consecutive columns from these rows. At this step, we have all 3x3 contiguous submatrices Ẏ Unwrap by one layer; previously grouped by rows, now ungrouped µ µ€ For each 3x3 submatrix F Flatten it Ḋ Get rid of the first element m2 Take every second element (this only keeps the edges) ṙ- Rotate right 1 element s2 Group into pairs; now the top and bottom are grouped and the left and right are grouped Ṣ€ Sort each pair Ṣ Sort the pairs F Flatten ċ4R¤ Count the number of occurrences of range(4); i.e. [1,2,3,4] 

-3 bytes thanks to Jonathan Allan (2) and Mr. Xcoder (3) (merged)

Java 8, 135 133 131 bytes

m->{int r=0,i=0,j;for(;++i<m.length-1;)for(j=1;j<m[i].length-1;)if(~(m[i-1][j]*m[i+1][j])*~(m[i][j-1]*m[i][++j])==39)r++;return r;} 

-2 bytes thanks to @tehtmi for a shorter formula: (l*r-1)*(t*b-1)==11 to ~(l*r)*~(t*b)==39

Explanation:

Try it online.

m->{ // Method with integer-matrix parameter and integer return-type int r=0, // Result-integer, starting at 0 i=0,j; // Index integers for(;++i<m.length-1;) // Loop over the rows, skipping the first and last for(j=1;j<m[i].length-1;) // Inner loop over the columns, skipping the first and last if(~(m[i-1][j]*m[i+1][j])*~(m[i][j-1]*m[i][++j])==39) // If (-(bottom*top)-1) * (-(left*right)-1) is exactly 39: r++; // Increase the result-counter by 1 return r;} // Return the result-counter 

Husk, 23 bytes

#ö§&¦ḣ4SδΛ≈↔Ċ2tΣṁoX3TX3 

Try it online!

Explanation

#ö§&¦ḣ4SδΛ≈↔Ċ2tΣṁoX3TX3 Implicit input, a list of lists of integers. X3 Length-3 slices. ṁ Map over them and concatenate: T Transpose, oX3 then get length-3 slices. Now we have a list of 3x3-arrays of the (transposed) input. #ö Return number of 3x3-arrays that satisfy this: Take m = [[0,3,0],[2,4,1],[1,4,0]] as an example. Σ Concatenate: [0,3,0,2,4,1,1,4,0] t Tail: [3,0,2,4,1,1,4,0] Ċ2 Take every second element: c = [3,2,1,4] §& c satisfies both of the following: ¦ 1) It contains every element of ḣ4 the range [1,2,3,4]. Sδ 2) If you zip c ↔ with its reverse, Λ then each corresponding pair ≈ has absolute difference at most 1. Implicitly print the result. 

Python 3, 120 118 bytes

lambda x:sum({x[i+1][j]*x[i+1][j+2],x[i][j+1]*x[i+2][j+1]}=={2,12}for i in range(len(x)-2)for j in range(len(x[0])-2)) 

Try it online!

Uses the fact that the product of opposite pairs of numbers in the cross must be 2 and 12 respectively, and compares with a set to cover all the different orientations. Takes input as a 2D array of integers.

Dyalog APL, 30 29 28 27 26 bytes (SBCS)

+/∘,{12 2⍷×∘⌽⍨⊢/4 2⍴⍵}⌺3 3 

Try it online!

Jelly, 36 bytes

“ƒɦƈạ%ȤFE’b4s4 ṡ3µZṡ3F€µ€ẎḊm2$$€’f¢L 

Try it online!

37 bytes

For some reason I can't move the Ḋm2$$ to the top link.

ṙ1s2I€FPA,P⁼1,24 ṡ3µZṡ3F€µ€ẎḊm2$$€Ç€S 

Try it online!

Clean, 255 ... 162 bytes

It isn't beneficial that often to use pattern filters in comprehensions, but in this case, it is.

import StdEnv,StdLib ? =reverse @ =transpose t=tails $m=sum[1\\f<-[id,@,?,?o@,@o?,@o?o@,?o@o?o@,?o@o?],[a,b,c:_]<-t(f m),[_,1:_]<-t a&[3,_,4:_]<-t b&[_,2:_]<-t c] 

Try it online!

Defines the function $, taking [[Int]] and returning Int.

It first generates all symmetries of the matrix m (transforming via f), takes the tails of which have three or more rows, and synchronously checks how many of the first three sets of columns from the tails of each row match the pattern of the cross.

This is equivalent to counting the number of ordered tails-of-tails matching the pattern [[_,1,_:_],[3,_,4:_],[_,2,_:_]:_] - which is in turn logically the same as checking if, for each cell in the matrix, that cell is the upper-left corner of any rotation of the cross.

Japt -x, 39 38 33 bytes

ã3 Ëmã3 y x@[XXy]®g1 ë2 ×Ãn e[2C] 

Try it online!

-1 byte thanks to @Shaggy.

-5 bytes thanks to @ETHproductions by refactoring the array.

Unpacked & How it works

Uã3 mD{Dmã3 y xX{[XXy]mZ{Zg1 ë2 r*1} n e[2C] Input: 2D Array of numbers Uã3 Generate an array of length 3 segments of U mD{ Map... (D = 2D array of numbers having 3 rows) Dmã3 Map over each row of D to generate an array of length 3 segments y Transpose; make an array of 3x3 subsections xX{ Map and sum... (x = 3x3 2D array of numbers) [XXy] Array of X and X transposed mZ{ Map... Zg1 ë2 r*1 Take row 1, take 0th and 2nd elements, reduce with * } n Sort the array e[2C] Equals [2,12] element-wise? Implicit cast from boolean to number Result: 1D array of counts -x Sum of the result array 

There should still be a better way to test for the cross...