SafeMath and user input: it's always possible to overflow/underflow. No way out?

Question

SafeMath doesn't prevent overflow/underflow from user input.

Example:

function sub(uint8 a, uint8 b) public returns(uint8) {
   require(b <= a);
   uint8 c = a - b;
   return c;
}

Say the user inputs a == 30 and b == 260, it will pass, since by the time the scope of the function is executed, b has already been overflown to 4.

Is there no way of preventing that, other than preventing that input on the client side?

My point is that SafeMath is not nearly safe when you are dealing with user input. But checking that on the client side isn't safe either, since it's always possible to interact with a contract "directly", bypassing any front-end application.

What am I missing here?

Answer 1

The point is that if you write ‘260’ for b you are not writing uint8 as in your example, but at least uint9.

This is not an overflow, but a wrong intended input, which maps in a normal input for the function.

From the point of view of the function nothing happened.

Any limited size uint representation is intended as limited to the representable universe for that representation.

It make not sense to worry about if a 20 bit address does not represent properly a 32 bit address: it is obvious.

You are worried about the fact that uint8 cannot map properly any uint9.

So what is wrong here?

The overflow (underflow in this case) should be the case of a:

uint(30) - uint(260) = ?

where both 30 and 260 are valid number in uint256 representation (I.e. uint).

Answer 2

I believe you are simply reading it wrong.

The values are compared prior to any execution of subtraction.

Line 2 above, require(b <= a); will throw prior to the subtraction on line 3.