This completely depends on what the server does with the provided hash. If the server simply puts that hash into its database, and then compares the hash you send to the value in the database, then yes, that would have the problems you describe.
Instead, the way this should be done is to first stretch the password locally, and then hash again on the server. "Stretching" means to apply a time-intensive key derivation function (KDF), most commonly PBKDF2. This mixes additional "salt" data into the password, and applies a hash function in a specific way to convert a human-provided password into something that is "effectively random." How that salt data is generated depends on the system. It may be random, or it may be based on some static but unique piece of information such as the user's id. There are several approaches here that provide reasonable trade-offs.
The resulting stretched value should then be sent to the server. Doing it this way ensures that the server never sees the user's actual password.
Once the server has this value, it should then apply some fast cryptographic hash function (SHA-2 most commonly) to that value and use that hash to compare to the database value. Doing it this way ensures that even if an attacker has access to the database, they cannot use that to directly login.
Based on your edit, I suspect that what they're actually sending is an encrypted password or encrypted hash. They are probably encoding something like a timestamp in the encryption. Whether this is implemented in a secure way depends highly on the details, but there is nothing inherently insecure about this approach. (The fact that old hashes are reusable is not ideal, but whether it is a significant concern depends on the rest of the system.)
As a first guess, I would assume it's insecure and badly designed, but only because this is always the working assumption when assessing a security system until proven otherwise. Without exploring the details, it's not possible to evaluate this system, but nothing you've described is incompatible with a good system.