Resolving GitHub SSH Connection Timeout Error: Comprehensive Analysis and Solutions for Port 22 Blocking

Problem Phenomenon and Error Analysis

When using Git for version control, developers frequently need to push local repositories to remote GitHub repositories. The typical workflow includes setting the remote repository address:

git remote add origin git@github.com:alicht/tweetanuber.git

Followed by executing the push command:

git push -u origin master

However, in certain network environments, developers encounter the following error message:

ssh: connect to host github.com port 22: Operation timed out
fatal: Could not read from remote repository.

Please make sure you have the correct access rights
and the repository exists.

This error indicates that the Git client cannot connect to GitHub servers via the SSH protocol. The "Operation timed out" in the error message suggests that connection attempts received no response within the timeout period, while "port 22" specifies the standard port used by the SSH protocol.

Root Cause Investigation

SSH connection timeout errors typically originate from network-level access restrictions. Git defaults to using the SSH protocol for secure communication, which relies on TCP port 22. When connection timeouts occur, the primary potential causes include:

• Local firewall configuration: Operating systems or security software may block outbound connections to port 22
• Internet Service Provider (ISP) restrictions: Certain network environments (such as corporate networks, public Wi-Fi, or ISPs in specific regions) may actively block SSH ports to prevent potential security risks
• Intermediate network device filtering: Routers, proxy servers, or gateway devices may have port filtering rules configured
• GitHub server-side temporary issues: While less common, GitHub's own network problems could also cause connection failures

It's important to note that this error is unrelated to repository permissions or existence—the prompts about permissions and repository existence in the error message are generic suggestions, but in this specific case, the core issue is network connectivity rather than authentication or repository configuration.

Core Solution: HTTPS Protocol Alternative

The most direct and effective solution is to switch to the HTTPS protocol for Git operations. HTTPS uses standard port 443, which is rarely blocked by firewalls or ISPs since it's the standard port for web traffic. Here are the specific implementation steps:

1. Add HTTPS remote repository: Add a new remote endpoint to the existing repository using HTTPS URL format

git remote add origin-https https://github.com/alicht/tweetanuber.git

2. Verify HTTPS connection: Attempt to push through the newly added HTTPS endpoint

git push -u origin-https master

If HTTPS push succeeds, this confirms that the root cause is indeed SSH port 22 being blocked. At this point, developers can choose to:

• Continue using HTTPS protocol for all Git operations
• Permanently change the default remote repository URL to HTTPS format

git remote set-url origin https://github.com/alicht/tweetanuber.git

The advantage of HTTPS protocol lies in its broad network compatibility, but note that using HTTPS may require more frequent GitHub credential input (unless credential caching is configured).

Supplementary Solutions and Optimization Recommendations

Beyond the HTTPS alternative, other methods can resolve or bypass SSH connection issues:

SSH Configuration Optimization

By modifying SSH client configuration, you can attempt to use alternative ports or connection parameters. Edit or create the SSH configuration file:

Host github.com
  Hostname ssh.github.com
  Port 443

This configuration directs the SSH client to connect to GitHub's SSH service via port 443 (HTTPS port), utilizing GitHub's SSH over HTTPS functionality. This method maintains the advantages of SSH protocol (such as key authentication) while avoiding the blocked port 22.

Network Diagnostics and Troubleshooting

Before implementing solutions, basic network diagnostics help confirm the problem scope:

1. Test SSH connection: Use command-line tools to directly test SSH connection to GitHub

ssh -T git@github.com

2. Check port accessibility: Use network tools to test connectivity on ports 22 and 443
3. Verify DNS resolution: Ensure github.com domain correctly resolves to IP addresses

Long-term Solution Considerations

For developers who frequently need SSH protocol, consider the following long-term solutions:

• Coordinate with network administrators: In enterprise environments, request outbound SSH connection permissions
• Use VPN services: Establish encrypted tunnels via VPN to bypass local network restrictions
• Configure SSH tunneling: Establish SSH tunnels through other available ports

Protocol Selection and Security Considerations

When choosing between SSH and HTTPS protocols, weigh the following factors:

For most developers, HTTPS protocol offers the best out-of-the-box compatibility, particularly in restricted network environments. GitHub's official documentation suggests that HTTPS serves as a reliable fallback when SSH connections encounter problems.

Implementation Example and Verification

The following complete example demonstrates the full workflow from SSH failure to HTTPS success:

# Initial state: SSH push fails
git push -u origin master
# Output: ssh: connect to host github.com port 22: Operation timed out

# Add HTTPS remote endpoint
git remote add github-https https://github.com/alicht/tweetanuber.git

# Push via HTTPS
git push -u github-https master
# Output: Successful push, prompts for GitHub credentials

# Optional: Set up credential caching to avoid repeated input
git config --global credential.helper cache

# Optional: Permanently switch default remote repository to HTTPS
git remote set-url origin https://github.com/alicht/tweetanuber.git

Through this approach, developers can quickly restore Git workflows while maintaining continuity in code version control.

Conclusion and Best Practices

The GitHub SSH connection timeout error is a common network compatibility issue, primarily stemming from port 22 being blocked by firewalls or ISPs. HTTPS protocol provides the most direct and reliable solution by using standard web port 443 to bypass common network restrictions. Developers should:

1. First attempt HTTPS alternatives to confirm the nature of the problem
2. Choose the most suitable protocol based on work environment (HTTPS for maximum compatibility, SSH for automation scenarios)
3. Configure appropriate credential management to reduce repeated authentication
4. Clearly define protocol selection in team collaborations to ensure consistency

By understanding the nature of network restrictions and how Git protocols work, developers can effectively resolve connection issues and ensure smooth code management workflows. GitHub's full support for both protocols makes protocol selection a configuration item optimized for specific environments rather than a technical limitation.