I don't think the old ciphersuites are too much of a worry in themselves as your server should not ever negotiate them. What is more of a worry is that they indicate that the SSL/TLS stack in the client in general is very old.
In general with ssl/tls the client authenticates the server but the server does not authenticate the client at a tls level, (higher level protocols will often authenticate the client using their own mechanisms but that authentication doesn't provide MITM protection).
So the type of problems you need to worry about are issues that let the attacker convince the client that they are the server and hence allow the attacker to MITM the connection.
One method of doing that is to attack the certificate hash algorithm. There are two variants of this.
If the attacker has a feasible preimage attack against the cerficate then they can easilly use to make themselves a trusted certificate for any hostname they like. However afaict even for very old hash functions like MD2 preimage attacks are still computationally infesible.
The other method is to exploit a collision attack to create a pair of certificates one of which is a normal end entity cert for a domain the attacker legitimately owns and is signed by a trusted CA. The other certificate is an intermediate CA certificate. The two certificates are constructed to have the same hash which allows the signature to be transplanted. However to pull this off the attacker needs to find a CA that still uses the vulnerable hash function and that operates predictablly enough that the collision attack can succeed. A group of University researchers did manage to pull this attack off with MD5 but the CA they used changed thier practices immediately afterwards.
Another option is to go after the RSA keys themselves. If you can find a CA certificate that the client will trust (either directly as a root certificate or indirectly as an intermediate signed by one of the clients root certificates) with a sufficiently short RSA key then you can factor the modulus and get the private key. Then you can use it to sign certificates for whatever hostname you like. 512 bit RSA is easilly factored but i'm not sure if it was ever used on CA certificates (it was used on end entity certificates but those tend to have shorter expiry and are only useful for impersonating one site) 1024 bit RSA was widely used on root certificates and is probablly crackable with NSA-level resources but is almost certainly still out of the reach of common criminals.