Python 2, 30 bytes

lambda a,b:a in(b,5-b,b-5,b+5)

Try it online!

_{One byte saved by Arnauld}

_{Three bytes saved by alephalpha}

JavaScript (ES6), 28 bytes

Takes input as (a)(b). Returns $0$ or $1$.

a=>b=>a+b==5|!(a-=b)|a*a==25

Try it online!

Dyalog APL, 9 bytes

=∨5∊+,∘|-

Try it online!

Spelled out:

  =   ∨  5      ∊                +   , ∘    |            -

equal or 5 found in an array of sum and absolute of difference.

x86 machine code, 39 bytes

00000000: 6a01 5e6a 055f 5251 31c0 39d1 0f44 c601  j.^j._RQ1.9..D..

00000010: d139 cf0f 44c6 595a 29d1 83f9 050f 44c6  .9..D.YZ).....D.

00000020: 83f9 fb0f 44c6 c3                        ....D..

Assembly

section .text

	global func

func:					;inputs int32_t ecx and edx

	push 0x1

	pop esi

	push 0x5

	pop edi

	push edx

	push ecx

	xor eax, eax



	;ecx==edx?

	cmp ecx, edx

	cmove eax, esi



	;ecx+edx==5?

	add ecx, edx

	cmp edi, ecx

	cmove eax, esi

	

	;ecx-edx==5?

	pop ecx

	pop edx

	sub ecx, edx

	cmp ecx, 5

	

	;ecx-edx==-5?

	cmove eax, esi

	cmp ecx, -5

	cmove eax, esi



	ret

Try it online!

R, 40 bytes (or 34)

function(x,y)any((-1:1*5)%in%c(x+y,x-y))

Try it online!

For non-R users:

• 
  -1:1*5 expands to [-5, 0, 5]
  


• the %in% operator takes elements from the left and checks (element-wise) if they exist in the vector on the right

A direct port of @ArBo's solution has 35 34 bytes, so go upvote that answer if you like it:

function(x,y)x%in%c(y--1:1*5,5-y)

Jelly, 7 bytes

+,ạ5eo=

Try it online!

How it works

+,ạ5eo=  Main link. Arguments: x, y (integers)



+        Yield x+y.

  ạ      Yield |x-y|.

 ,       Pair; yield (x+y, |x-y|).

   5e    Test fi 5 exists in the pair.

      =  Test x and y for equality.

     o   Logical OR.

J, 12 11 bytes

1 byte saved thanks to Adám

1#.=+5=|@-,+

Try it online!

Explanation

This is equivalent to:

1 #. = + 5 = |@- , +

This can be divided into the following fork chain:

(= + (5 e. (|@- , +)))

Or, visualized using 5!:4<'f':

  ┌─ =               

  ├─ +               

──┤   ┌─ 5           

  │   ├─ e.          

  └───┤          ┌─ |

      │    ┌─ @ ─┴─ -

      └────┼─ ,      

           └─ +      

Annotated:

  ┌─ =                                     equality

  ├─ +                                     added to (boolean or)

──┤   ┌─ 5                                   noun 5

  │   ├─ e.                                  is an element of

  └───┤          ┌─ |  absolute value         |

      │    ┌─ @ ─┴─ -  (of) subtraction       |

      └────┼─ ,        paired with            |

           └─ +        addition               | any of these?

Python 2, 38 bytes

-2 bytes thanks to @DjMcMayhem

lambda a,b:a+b==5or abs(a-b)==5or a==b

Try it online!

Java (JDK), 30 bytes

a->b->a+b==5|a==b|(b-=a)*b==25

Try it online!

Wolfram Language (Mathematica), 22 bytes

Takes input as [a][b].

MatchQ[#|5-#|#-5|#+5]&

Try it online!

Python 2, 29 31 bytes

lambda a,b:a+b==5or`a-b`in"0-5"

Try it online!

Since I didn't manage to read the task carefully the first time, in order to fix it, I had to come up with a completely different approach, which is unfortunately not as concise.

PowerShell, 48 44 40 bytes

param($a,$b)$b-in($a-5),(5-$a),(5+$a),$a

Try it online! or Verify all Test Cases

Takes input $a and $b. Checks if $b is -in the group ($a-5, 5-$a 5+$a, or $a), which checks all possible combinations of $a,$b, and 5.

-4 bytes thanks to mazzy.
-4 bytes thanks to KGlasier.

8086 machine code, 22 20 bytes

8bd0 2bc3 740e 7902 f7d8 3d0500 7405 03d3 83fa05

Ungolfed:

ESD  MACRO

    LOCAL SUB_POS, DONE

    MOV  DX, AX     ; Save AX to DX

    SUB  AX, BX     ; AX = AX - BX

    JZ   DONE       ; if 0, then they are equal, ZF=1

    JNS  SUB_POS    ; if positive, go to SUB_POS

    NEG  AX         ; otherwise negate the result

SUB_POS:

    CMP  AX, 5      ; if result is 5, ZF=1

    JZ   DONE

    ADD  DX, BX     ; DX = DX + BX

    CMP  DX, 5      ; if 5, ZF=1

DONE:

    ENDM

Input numbers in AX and BX and returns Zero Flag (ZF=1) if result is true. If desired, you can also determine which condition was true with the following:

• ZF = 1 and DX = 5 ; sum is 5


• ZF = 1 and AX = 5 ; diff is 5


• ZF = 1 and AX = 0 ; equal


• ZF = 0 ; result false

If the difference between the numbers is 0, we know they are equal. Otherwise if result is negative, then first negate it and then check for 5. If still not true, then add and check for 5.

Sample PC DOS test program. Download it here (ESD.COM).

START:

    CALL INDEC      ; input first number into AX

    MOV  BX, AX     ; move to BX

    CALL INDEC      ; input second number into BX

    ESD             ; run "Equal, sum or difference" routine

    JZ   TRUE       ; if ZF=1, result is true

FALSE:

    MOV  DX, OFFSET FALSY   ; load Falsy string

    JMP  DONE

TRUE:

    MOV  DX, OFFSET TRUTHY  ; load Truthy string

DONE:

    MOV  AH, 9      ; DOS display string

    INT  21H        ; execute

    MOV  AX, 4C00H  ; DOS terminate

    INT  21H        ; execute



TRUTHY   DB 'Truthy$'

FALSY    DB 'Falsy$'



INCLUDE INDEC.ASM   ; generic decimal input prompt routine

Output of test program:

A>ESD.COM

: 4

: 1

Truthy



A>ESD.COM

: 10

: 10

Truthy



A>ESD.COM

: 1

: 3

Falsy



A>ESD.COM

: 6

: 2

Falsy



A>ESD.COM

: 1

: 6

Truthy



A>ESD.COM

: -256

: -251

Truthy



A>ESD.COM

: 6

: 1

Truthy



A>ESD.COM

: 9999999999

: 9999999994

Truthy

C# (.NET Core), 43, 48, 47, 33 bytes

EDIT: Tried to use % and apparently forgot how to %. Thanks to Arnauld for pointing that out!

EDIT2: AdmBorkBork with a -1 byte golf rearranging the parentheses to sit next to the return so no additional space is needed!

EDIT3: Thanks to dana for -14 byte golf for the one-line return shortcut and currying the function (Ty Embodiment of Ignorance for linking to TIO).

C# (.NET Core), 33 bytes

a=>b=>a==b|a+b==5|(a-b)*(a-b)==25

Try it online!

C (gcc), 33 bytes

f(a,b){a=!(a+b-5&&(a-=b)/6|a%5);}

Try it online!

Tried an approach I didn't see anyone else try using. The return expression is equivalent to a+b==5||((-6<a-b||a-b<6)&&(a-b)%5==0).

Scala, 43 bytes

def f(a:Int,b:Int)=a+b==5|(a-b).abs==5|a==b

Try it online!

Perl 6, 24 bytes

-1 byte thanks to Grimy

{$^a-$^b==5|0|-5|5-2*$b}

Try it online!

This uses the Any Junction but technically, ^ could work as well.

Explanation:

{                      }  # Anonymous code block

 $^a-$^b==                # Is the difference equal to

           | |  |        # Any of

          0 

            5

              -5

                 5-2*$b

Python 2, 25 bytes

lambda a,b:(a*a-b*b)%5==0

Try it online!

C (gcc), 41 34 bytes

f(a,b){a=5==abs(a-b)|a+b==5|a==b;}

Try it online!

Tcl, 53 bytes

proc P a b {expr abs($a-$b)==5|$a==$b|abs($a+$b)==5}

Try it online!

Japt, 14 13 bytes

¥VªaU ¥5ª5¥Nx

Try it online!

05AB1E, 13 12 bytes

ÐO5Qs`α5QrËO

Try it online!

Takes input as a list of integers, saving one byte. Thanks @Wisław!

Alternate 12 byte answer

Q¹²α5Q¹²+5QO

Try it online!

This one takes input on separate lines.

Batch, 81 bytes

@set/as=%1+%2,d=%1-%2

@if %d% neq 0 if %d:-=% neq 5 if %s% neq 5 exit/b

@echo 1

Takes input as command-line arguments and outputs 1 on success, nothing on failure. Batch can't easily do disjunctions so I use De Morgan's laws to turn it into a conjunction.

05AB1E, 10 bytes

OIÆ‚Ä50SåZ

Try it online!

O           # Sum the input.

 IÆ         # Reduced subtraction of the input.

   ‚        # Wrap [sum,reduced_subtraction]

    Ä       # abs[sum,red_sub]

     50S    # [5,0]

        å   # [5,0] in abs[sum,red_sub]?

         Z  # Max of result, 0 is false, 1 is true.

Tried to do it using stack-only operations, but it was longer.

Charcoal, 18 bytes

Ｎθ¿№⟦θ⁺⁵θ⁻⁵θ⁻θ⁵⟧Ｎ1

Try it online! Link is to verbose version of code. Port of @ArBo's Python 2 solution.

Japt, 13 12 bytes

x ¥5|50ìøUra

Try it or run all test cases

x ¥5|50ìøUra

                 :Implicit input of array U

x                :Reduce by addition

  ¥5             :Equal to 5?

    |            :Bitwise OR

     50ì         :Split 50 to an array of digits

        ø        :Contains?

         Ur      :  Reduce U

           a     :    By absolute difference

Common Lisp, 48 bytes

(lambda(a b)(find 5(list(abs(- b a))a(+ a b)b)))

Runic Enchantments, 30 bytes

i::i::}3s=?!@-'|A"5"n:}=?!@+=@

Try it online!

With a pending update, 4 bytes can be saved, as presently integer inputs are treated as doubles and don't equal integers of the same value. Hence "5"n instead of just 5. This was an oversight and several factors are being adjusted to account for it (such as using Approximately(a, b) instead of a.Equals(b)).

Outputs 0 (exactly one zero) for false and any other output (literally whatever is left on the stack) for true.

Retina 0.8.2, 82 bytes

d+

$*

^(-?1*) 1$|^(-?1*)1{5} -?2$|^-?(-?1*) (3)1{5}$|^-?(1 ?){5}$|^(1 ?-?){5}$

Try it online! Link includes test cases. Explanation: The first two lines convert the inputs into unary. The final line then checks for any of the permitted matches:

^(-?1*) 1$                              x==y

^(-?1*)1{5} -?2$   x>=0 y>=0 x=5+y i.e. x-y=5

                    x>=0 y<=0 x=5-y i.e. x+y=5

                    x<=0 y<=0 x=y-5 i.e. y-x=5

^-?(-?1*) (3)1{5}$ x<=0 y<=0 y=x-5 i.e. x-y=5

                    x<=0 y>=0 y=5-x i.e. x+y=5

                    x>=0 y>=0 y=5+x i.e. y-x=5

^-?(1 ?){5}$        x>=0 y>=0 y=5-x i.e. x+y=5

                    x<=0 y>=0 y=5+x i.e. y-x=5

^(1 ?-?){5}$        x>=0 y>=0 x=5-y i.e. x+y=5

                    x>=0 y<=0 x=5+y i.e. x-y=5

Pivoted by the last column we get:

x==y            ^(-?1*) 1$

x+y=5 x>=0 y>=0 ^-?(1 ?){5}$

      x>=0 y>=0 ^(1 ?-?){5}$

      x>=0 y<=0 ^(-?1*)1{5} -?2$

      x<=0 y>=0 ^-?(-?1*) (3)1{5}$

      x<=0 y<=0 (impossible)       

x-y=5 x>=0 y>=0 ^(-?1*)1{5} -?2$

      x>=0 y<=0 ^(1 ?-?){5}$

      x<=0 y>=0 (impossible)

      x<=0 y<=0 ^-?(-?1*) (3)1{5}$

y-x=5 x>=0 y>=0 ^-?(-?1*) (3)1{5}$

      x>=0 y<=0 (impossible)

      x<=0 y>=0 ^-?(1 ?){5}$

      x<=0 y<=0 ^(-?1*)1{5} -?2$

Perl 5, 51 bytes

Pretty simple really, uses the an flags for input. Outputs 0 for false, 1 for true. Not gonna lie, I don't know if bitwise OR is appropriate here, but is does work for all the test cases, so that's nice.

($a,$b)=@F;print($a==$b|$a+$b==5|$a-$b==5|$b-$a==5)

Try it online!