Код ошибки ssl error bad mac read

Facing ERR_SSL_BAD_RECORD_MAC_ALERT error when you try to access a web address, Right? Here ClickSSL guide can help you.

An SSL Certificate makes use of cryptography to transmit information between the server and the client securely. However, there are times when specific network interferences or interruptions can cause SSL errors like the ERR_SSL_BAD_RECORD_MAC_ALERT pop-up. This is one of the most annoying errors that keep you from accessing even the most reputed and trusted websites. Nevertheless, you must fix it as early as possible so that you can access your favorite websites without any further inconvenience.

What is ERR_SSL_BAD_RECORD_MAC_ALERT?

The ERR_SSL_BAD_RECORD_MAC_ALERT error is exclusive to the Chrome browser and may arise due to several reasons, which are either directly or indirectly connected to data transmission. Although pinpointing the exact cause for this issue might not be an easy thing to do, fixing it is, and that is precisely what you should focus on. If this is the first time you have encountered this type of error, you are probably worried about your safety, but you don’t have to.

This technical glitch is often caused due to some underlying problem on the client computer and can be easily verified. You can confirm that by trying to access legitimate websites like paypal.com that already have an SSL certificate installed and are running on the HTTPS protocol. If you continue to encounter the same error, it only confirms the above stated — it is a client-side issue that you need to resolve. As we have already mentioned, detecting the cause for this issue may not always be possible — not until you find a suitable solution, so you will have to try them out one by one. Let us now discuss some of the most effective ways to solve the ERR_SSL_BAD_RECORD_MAC_ALERT error.

1. Update your OS

Do you have a licensed operating system and update it from time to time? Probably not! But doing that could help resolve this SSL error and many other pre-existing vulnerabilities in your system. Your OS maker releases security patches from time to time in the form of updates. Downloading and installing those updates can not only prevent security concerns but can also fix technical glitches this SSL error.

Follow the below-mentioned steps to update your Windows OS right away.

• Click on the windows button and type ‘Settings’ in the search bar
• Click on Settings
• Click on the ‘Updates and Security’ Option
• Click on the ‘Download and Install’ Option

Once you are done updating your system, you might be prompted to restart your computer.

2. Update Google Chrome

Sometimes, updating the Google Chrome browser can resolve the ERR_SSL_BAD_RECORD_MAC_ALERT issue. You can do that by clicking on the three vertical dots on the top-right corner of the Chrome Browser and clicking on ‘more’. If you find the ‘update’ option, you need to click on that to update your browser.

On the other hand, if you do not see that option, it only indicates that your Chrome Browser is up to date. You can always confirm that by clicking on the three vertical dots on the top-right corner and then on ‘help’ and ‘About Google Chrome’. If your system is up to date, you will find a message like the one shown in the image below.

3. Antivirus

If you recently installed an Antivirus and have been experiencing this error ever since you already know what the problem is. It is never a good idea to meddle with your antivirus’ settings, but sometimes it becomes inevitable. Particularly, when you are using one that inspects the HTTPS and blocks out potentially dangerous traffic. In that case, you need to deactivate the HTTPS Inspection from your antivirus’ settings. However, please do this at your own risk and continue to avoid websites without SSL certificates installed on them.

4. Stop using Advanced Streaming Technologies

If you fancy high-speed internet, you most likely have a speed optimizing application or more advanced technology like a Killer Network card installed on your system. That could very well be the root cause of the ERR_SSL_BAD_RECORD_MAC_ALERT issue. The application or the Killer Network assigns a high priority to the data packets to boost the internet speed, which can sometimes cause this SSL error.

You can conveniently fix that by simply turning down the ‘Stream Detect’ function in your Killer Control Center or by uninstalling the speed-boosting application. Sometimes, your Killer Network card might need a more advanced solution. In that case, uninstall it by following the steps listed below.

• You need to first download the uninstaller tool from here
• Next, choose the Remove Killer Software option to uninstall
• Finally, restart the computer when prompted to do that, and you are done

Remember that fixing this issue could lower your internet speed, so you must be prepared for that.

5. Fix your Router

If none of the above fixes worked, your router could very well be the culprit. You can fix that by adjusting the Maximum Transmission Unit (MTU) of your router. This might sound a tad bit technical, but all it means is the maximum packet size that can be transmitted over the network. It is an advanced configuration that can be readjusted easily by typing 192.168.0.1. or 192.168.1.1. in the URL bar.

You can then look for the MTU settings under WAN and change it to 1400. In most cases, this should solve the problem, but we must mention that different routers may have different IPs and the ones mentioned above are the default ones.

Conclusion

We have discussed some of the most common ways to fix the ERR_SSL_BAD_RECORD_MAC_ALERT error, and one of those should work for you. None of these methods requires you to have any technical expertise, so try them out one at a time. Once you have resolved the error, do let us know which one worked out for you.

Recommended Reading:

• NET::ERR_CERT_AUTHORITY_INVALID Error on Google Chrome
• ERR_BAD_SSL_CLIENT_AUTH_CERT for Google Chrome
• NET::ERR_Certificate_Transparency_Required
• ERR_SSL_PROTOCOL_ERROR on Google Chrome
• ERR_CONNECTION_REFUSED in Chrome

Many Thanks to @steffen-ullrich, This is final solution for who comes later. works for http/https:

package main

import (
    "fmt"
    "net"
    "strings"
)

func main() {
    fmt.Println("Start server...")

    ln, _ := net.Listen("tcp", ":8000")

    for {
        conn, _ := ln.Accept()
        handleSocket(conn)
    }
}

func handleSocket(client_to_proxy net.Conn) {
    buffer := make([]byte, 32*1024)
    _, e := client_to_proxy.Read(buffer)
    if e != nil {
        fmt.Println("ERROR1 ", e)
        return
    }
    message := string(buffer)
    a := strings.Count(message, "rn")
    fmt.Println(message)
    fmt.Println(a)
    if e != nil {
        fmt.Println("ERROR1 ", e)
        return
    }

    splited := strings.Split(message, " ")
    //host := strings.Split(splited[1], ":")
    if splited[0] == "CONNECT" {
        //message = strings.Replace(message, "CONNECT", "GET", 1)
        proxy_to_server, e := net.Dial("tcp", splited[1])
        if e != nil {
            fmt.Println("ERROR2 ", e)
            return
        }
        //_, e = proxy_to_server.Write([]byte(message))
        //if e != nil {
        //  fmt.Println("ERROR2 ", e)
        //  return
        //}
        lenn, e := client_to_proxy.Write([]byte("HTTP/1.1 200 OKrnrn"))
        if e != nil {
            fmt.Println("ERROR8 ", e)
            return
        }
        fmt.Println(lenn)

        read443(client_to_proxy, proxy_to_server)
    } else if splited[0] == "GET" {
        host1 := strings.Replace(splited[1], "http://", "", 1)
        host2 := host1[:len(host1)-1]
        var final_host string
        if strings.LastIndexAny(host2, "/") > 0 {
            final_host = host2[:strings.LastIndexAny(host2, "/")]
        } else {
            final_host = host2
        }
        proxy_to_server, e := net.Dial("tcp", final_host+":80")
        if e != nil {
            fmt.Println("ERROR7 ", e)
            return
        }
        _, e = proxy_to_server.Write([]byte(message))
        if e != nil {
            fmt.Println("ERROR6 ", e)
            return
        }

        write80(client_to_proxy, proxy_to_server)
    }
}

func write80(client_to_proxy net.Conn, proxy_to_server net.Conn) {
    buffer := make([]byte, 64*1024)

    readLeng, err := proxy_to_server.Read(buffer)
    if err != nil {
        fmt.Println("ERROR9 ", err)
        return
    }
    fmt.Println("WRIIIIIIIIIIIIIIIIIIIIIIT from server:")
    fmt.Println(string(buffer[:readLeng]))
    if readLeng > 0 {
        _, err := client_to_proxy.Write(buffer[:readLeng])
        if err != nil {
            fmt.Println("ERR4 ", err)
            return
        }
    }

    go read80(client_to_proxy, proxy_to_server)
    for {
        readLeng, err := proxy_to_server.Read(buffer)
        if err != nil {
            fmt.Println("ERROR10 ", err)
            return
        }
        fmt.Println("WRIIIIIIIIIIIIIIIIIIIIIIT from server:")
        fmt.Println(string(buffer[:readLeng]))
        if readLeng > 0 {
            _, err := client_to_proxy.Write(buffer[:readLeng])
            if err != nil {
                fmt.Println("ERR4 ", err)
                return
            }
        }
    }
}

func read80(client_to_proxy net.Conn, proxy_to_server net.Conn) {
    buffer := make([]byte, 32*1024)

    for {
        readLeng, err := client_to_proxy.Read(buffer)
        if err != nil {
            return
        }
        fmt.Println("REEEEEEEEEEEEEEEEEEEEEEED from client:")
        fmt.Println(string(buffer[:readLeng]))
        if readLeng > 0 {
            _, err := proxy_to_server.Write(buffer[:readLeng])
            if err != nil {
                fmt.Println("ERR5 ", err)
                return
            }
        }
    }
}

func write443(client_to_proxy net.Conn, proxy_to_server net.Conn) {
    buffer := make([]byte, 32*1024)
    for {
        readLeng, err := proxy_to_server.Read(buffer)
        if err != nil {
            fmt.Println("ERROR10 ", err)
            return
        }
        fmt.Println("WRIIIIIIIIIIIIIIIIIIIIIIT from server:")
        fmt.Println(string(buffer[:readLeng]))
        if readLeng > 0 {
            _, err := client_to_proxy.Write(buffer[:readLeng])
            if err != nil {
                fmt.Println("ERR4 ", err)
                return
            }
        }
    }
}

func read443(client_to_proxy net.Conn, proxy_to_server net.Conn) {
    buffer := make([]byte, 32*1024)

    readLeng, err := client_to_proxy.Read(buffer)
    if err != nil {
        return
    }
    fmt.Println("REEEEEEEEEEEEEEEEEEEEEEED from client:")
    fmt.Println(string(buffer[:readLeng]))
    if readLeng > 0 {
        _, err := proxy_to_server.Write(buffer[:readLeng])
        if err != nil {
            fmt.Println("ERR5 ", err)
            return
        }
    }

    go write443(client_to_proxy, proxy_to_server)

    for {
        readLeng, err := client_to_proxy.Read(buffer)
        if err != nil {
            return
        }
        fmt.Println("REEEEEEEEEEEEEEEEEEEEEEED from client:")
        fmt.Println(string(buffer[:readLeng]))
        if readLeng > 0 {
            _, err := proxy_to_server.Write(buffer[:readLeng])
            if err != nil {
                fmt.Println("ERR5 ", err)
                return
            }
        }
    }
}