Error percentages are typically expressed as independent probabilities, meaning that if there are e.g. four bits which have a 1/3 error rate, there would be a 16/81 probability of no errors, a 32/81 probability of exactly one, a 24/81 probability of exactly two, an 8/81 probability of exactly three, and a 1/81 probability of all four bits being wrong. If the independent bit-error rate is non-zero, there is no way to have guarantee that incorrect data won't be delivered. The best one can do is achieve a certain probability of correct delivery, and given a 25% random error rate on a significant-sized payload one would need to have a really massive amount of overhead to achieve even a 90% probability of successful delivery.
In many real-world situations, however, errors will be strongly correlated. For example, the probability that a group of 64 consecutive bits in a packet might get replaced with random data could be much higher than the probability of having even four erroneous bits spread throughout the packet. It may be possible to deal much more effectively with strongly-correlated errors than with non-correlated errors. For example, if one wants to deliver 8192 bytes, one might divide them into groups of 16 bytes, each with a 16-bit CRC. Groups would be sent in pairs, with one being called 'even' and one being 'odd'. Attached to each meta-group of 16 pairs of groups would be an extra pair of groups, which represented the XOR of the data in the first 16 pairs (storing separately an 'even-group-XOR-group' and an 'odd-group-XOR-group'), and a 32-bit CRC. Attached to the payload would be an extra 'meta-group', whose data was the XOR of the previous 16 meta-groups, plus some larger validation check value (e.g. an MD5 hash)
If a single burst error occurs which is less than 16 bytes in length, it would at most splatter at most one even group and one odd group within a meta-group. Such corruption would likely be detected and could be corrected by taking the xor of the non-corrupted groups and the appropriate group-xor group. There would be a slight probability that the corruption might not be detected at that level, but the CRC32 of the meta group would fail. In that scenario, the receiver could check whether rejecting each group in sequence (reconstructing its data using the xor group) would yield a valid meta-group. If not, or if more than one even group or more than one odd group within a meta-group is corrupted, the code could discard the meta-group and reconstruct it using the xor-of-metagroups data. The correctness of the reconstruction could be assured using the overall-data validity check.
Note that this approach can work very well in protecting against isolated burst errors, and one may easily adjust the number of levels of hierarchy or the size of the various nested groups as needed for the application. The approach is not optimal for dealing with isolated random errors, but as noted a 25% random error rate is going to be very hard to deal with in any case.