1/22
Logowanie do GitHub z konsoli Linux
  • Witamy na wykładzie poświęconym autoryzacji i logowaniu do GitHub z poziomu terminala systemu Debian Linux.
  • Od sierpnia 2021 GitHub nie akceptuje już tradycyjnych haseł do operacji Git w konsoli.
  • Konieczne jest przejście na jedną z trzech bezpiecznych metod autoryzacji.
  • Poznasz krok po kroku: GitHub CLI, klucze SSH oraz Personal Access Token (PAT).
  • Każdą metodę skonfigurujemy od zera na świeżej instalacji Debiana.
  • Po tym wykładzie będziesz mógł w pełni pracować z GitHub w konsoli.
🔐

Zmiana polityki autoryzacji GitHub w sierpniu 2021 roku była podyktowana względami bezpieczeństwa. Hasła są podatne na phishing, wycieki i ponowne użycie. Tokeny i klucze SSH są kryptograficznie bezpieczniejsze, można im nadawać ograniczone uprawnienia oraz łatwo je unieważnić bez zmiany hasła do konta. Dla programisty oznacza to konieczność poznania nowych narzędzi, które jednak w dłuższej perspektywie znacząco usprawniają codzienną pracę. W środowisku akademickim szczególnie polecana jest metoda SSH, ponieważ raz skonfigurowana działa bezobsługowo przez cały okres studiów.

2/22
Dlaczego hasło nie działa?
  • Do 13 sierpnia 2021 GitHub akceptował hasło podczas git push, git pull, git clone przez HTTPS.
  • Od tego dnia przy próbie użycia hasła otrzymasz błąd: "Authentication failed" lub "Support for password authentication was removed".
  • GitHub uznał, że hasła są zbyt podatne na ataki – wycieki, phishing, słabe hasła.
  • Rozwiązanie: tokeny (PAT) i klucze SSH są bezpieczniejsze i dają większą kontrolę.
  • Token możesz wygenerować z konkretnymi uprawnieniami i datą ważności.
  • Klucz SSH jest powiązany z Twoim komputerem – bez pliku klucza nikt się nie zaloguje.
⚠ Komunikat błędu:
remote: Support for password authentication was removed on August 13, 2021.

Decyzja GitHub o wycofaniu uwierzytelniania hasłem nie była odosobniona – podobne kroki podjęły inne platformy, takie jak GitLab czy Bitbucket. Powód jest prosty: statystycznie ponad 80% naruszeń bezpieczeństwa wiąże się ze słabymi lub skradzionymi hasłami. Tokeny PAT mogą być wydawane z ograniczonym zakresem (np. tylko do odczytu repozytoriów), z określonym czasem ważności i mogą być natychmiast unieważnione w przypadku wycieku. SSH używa kryptografii klucza publicznego, co eliminuje konieczność przesyłania jakiegokolwiek sekretu przez sieć podczas uwierzytelniania.

3/22
Trzy metody logowania – przegląd
MetodaZaletyWady
1. GitHub CLI (gh) Najprostsza konfiguracja, kreator, automatyczne uwierzytelnienie Git Wymaga dodatkowego narzędzia, zależność od zewn. pakietu
2. Klucze SSH Bezhasłowe, najwygodniejsze na co dzień, działa bez dodatkowych narzędzi Początkowo wymaga więcej kroków, trzeba chronić klucz prywatny
3. Personal Access Token (PAT) Działa przez HTTPS, klasyczny workflow, łatwy do skryptowania Token trzeba odświeżać, ryzyko zapisania go w repozytorium
ℹ Rekomendacja: Na pierwszych zajęciach polecamy GitHub CLI (metoda 1). Do codziennej pracy na własnym komputerze – SSH (metoda 2).
✅ Wszystkie trzy metody są bezpieczne i oficjalnie wspierane przez GitHub.

Wybór metody zależy od scenariusza użycia. Na komputerach współdzielonych (laboratoria uczelniane) lepiej sprawdzi się GitHub CLI lub token PAT, ponieważ nie pozostawiamy trwałego klucza prywatnego. Na własnym laptopie SSH jest najwygodniejsze – po dodaniu klucza publicznego do GitHub nie musimy już wpisywać żadnych danych uwierzytelniających. W skryptach CI/CD (Continuous Integration/Continuous Deployment) standardem są tokeny PAT lub dedykowane tokeny deploy keys. Warto znać wszystkie trzy metody, aby móc dostosować się do wymagań każdego środowiska pracy.

4/22
Metoda 1: GitHub CLI – Wprowadzenie
  • GitHub CLI (gh) to oficjalne narzędzie wiersza poleceń wydane przez GitHub.
  • Pozwala zarządzać repozytoriami, issue, pull requestami i logowaniem wprost z terminala.
  • Proces logowania jest w pełni interaktywny – kreator przeprowadza przez wszystkie kroki.
  • Wykorzystuje mechanizm OAuth – nie musisz ręcznie generować żadnych tokenów.
  • Po zalogowaniu gh automatycznie konfiguruje Git do używania Twoich poświadczeń.
  • Jest to metoda rekomendowana przez GitHub dla początkujących.
gh

GitHub CLI powstał w 2019 roku i szybko stał się standardowym narzędziem dla programistów, którzy cenią pracę w terminalu. Oprócz uwierzytelniania, gh oferuje pełną integrację z API GitHub – można przeglądać issue, zatwierdzać pull requesty, zarządzać release'ami i wiele więcej bez opuszczania konsoli. W kontekście logowania kluczową zaletą jest to, że gh przechowuje token odświeżalny (refresh token) i automatycznie odnawia sesję, co eliminuje problem wygasających tokenów PAT. Narzędzie jest aktywnie rozwijane i dokumentowane na stronie cli.github.com.

5/22
Metoda 1: Instalacja GitHub CLI w Debian
  • W Debianie GitHub CLI jest dostępny w oficjalnych repozytoriach.
  • Wykonaj poniższe polecenia w terminalu:
$ sudo apt update
$ sudo apt install gh
  • Dla dystrybucji Debian będzie to (skopiuj i wklej w terminalu):
    $ (type -p wget >/dev/null || (sudo apt update && sudo apt install wget -y)) \
    $ && sudo mkdir -p -m 755 /etc/apt/keyrings \
    $ && out=$(mktemp) && wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg \
    $ && cat $out | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null \
    $ && sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \
    $ && sudo mkdir -p -m 755 /etc/apt/sources.list.d \
    $ && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null \
    $ && sudo apt update \
    $ && sudo apt install gh -y
  • W dystrybucji Ubuntu prawdopodobnie wystarczy sudo apt install gh
  • Sprawdź, czy instalacja się powiodła:
$ gh --version
gh version 2.49.0 (2024-04-30)
ℹ Aktualizacja: Jeśli potrzebujesz najnowszej wersji, dodaj oficjalne repozytorium GitHub CLI według instrukcji powyżej, a następnie: sudo apt install gh. Możesz też pobrać .deb z github.com/cli/cli/releases.
Uwaga: jeśli pracujesz w konsoli na maszynie bez GUI albo za pomocą SSH to po wydaniu polecenia gh auth login zaloguj się do swojego GitHub na innej maszynie w przeglądarce na adres: https://github.com/login/device. Wybierz swój profil i kliknij w 'Continue'. Następnie w oknie jakie się pojawi wpisz kod (ten pokazany na konsoli), przejdź dalsze kroki jakie pokaże Ci panel GitHub i po chwili na konsoli zobaczysz 'Authentication complete' czyli Twoja maszyna Linux widzi GitHub. Poniżej opisano wszystko w szczegółach.
Powinno to wyglądać jak niżej:
$ sudo apt install gh
Reading package lists... Done
Building dependency tree... Done
The following NEW packages will be installed:
gh
0 upgraded, 1 newly installed

W zależności od wersji Debiana (Debian 11 "Bullseye", Debian 12 "Bookworm") pakiet gh może być dostępny w różnych wersjach. Debian 12 Bookworm zawiera gh w wersji ~2.32, która jest w pełni funkcjonalna. Jeśli zależy Ci na najnowszej wersji, dodaj oficjalne repozytorium GitHub: type -p curl >/dev/null || sudo apt install curl -y && curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg && sudo chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null && sudo apt update && sudo apt install gh -y

6/22
Metoda 1: Uruchomienie logowania
  • Po instalacji wpisz w terminalu:
$ gh auth login
  • Kreator zada serię pytań. Oto odpowiedzi, które należy wybrać:
# 1. Wybierz konto:
? What account do you want to log into?
> GitHub.com
# 2. Wybierz protokół:
? What is your preferred protocol for Git operations?
> HTTPS
# 3. Czy skonfigurować Git automatycznie?
? Authenticate Git with your GitHub credentials?
> Yes
# 4. Sposób uwierzytelnienia:
? How would you like to authenticate GitHub CLI?
> Login with a web browser
🔗 Kreator wygeneruje 8-znakowy kod
np. WD31-A12B
i otworzy stronę github.com/login/device

Przebieg kreatora gh auth login jest taki sam niezależnie od systemu operacyjnego. Po wybraniu opcji "Login with a web browser" narzędzie wyświetli kod urządzenia (device code) i otworzy domyślną przeglądarkę. Jeśli pracujesz na serwerze bez interfejsu graficznego, przeglądarka się nie otworzy – wtedy musisz ręcznie wejść na adres https://github.com/login/device i wpisać wyświetlony kod. Po potwierdzeniu w przeglądarce terminal automatycznie zakończy proces logowania i poinformuje o sukcesie. Wszystkie dane uwierzytelniające są przechowywane w systemowym keychainie (jeśli jest dostępny) lub w pliku konfiguracyjnym ~/.config/gh/hosts.yml.

7/22
Metoda 1: Potwierdzenie w przeglądarce
  • Po wykonaniu gh auth login w przeglądarce pojawi się strona GitHub z polem na kod.
  • Wpisz kod wyświetlony w terminalu (np. WD31-A12B) i kliknij Continue.
  • GitHub poprosi o potwierdzenie uprawnień dla GitHub CLI:
✅ Krok po kroku w przeglądarce:
  1. Wejdź na https://github.com/login/device
  2. Wpisz 8-cyfrowy kod urządzenia
  3. Kliknij Authorize GitHub CLI
  4. Wpisz swoje hasło do GitHub (jeśli nie jesteś zalogowany)
  5. Gotowe ✓ – w terminalu zobaczysz komunikat: "Authentication complete"
Authentication complete. Press Enter to continue...
# po naciśnięciu Enter:
✓ Logged in as twoj_login
🔒 Device Activation
Enter the code shown on your device:
WD31-A12B
Continue

Mechanizm uwierzytelniania urządzenia (OAuth Device Authorization Grant) jest standardem protokołu OAuth 2.0 i jest używany przez wiele serwisów. Jest to szczególnie przydatne na serwerach bez przeglądarki – kod urządzenia jest krótki (8 znaków) i ważny przez ograniczony czas (standardowo 15 minut). GitHub CLI po pomyślnym uwierzytelnieniu zapisuje token odświeżalny (refresh token) w pliku konfiguracyjnym, co pozwala na automatyczne odświeżanie sesji bez ponownego logowania. Aby sprawdzić status logowania w dowolnym momencie, użyj komendy gh auth status.

8/22
Metoda 1: Weryfikacja i pierwsze użycie
  • Sprawdź, czy jesteś zalogowany:
$ gh auth status
✓ Logged in to github.com as twoj_login (HTTPS)
  • Git CLI został automatycznie skonfigurowany przez gh. Możesz od razu klonować i pushować:
# Klonowanie repozytorium (HTTPS):
$ gh repo clone twoj_login/nazwa_repo
Cloning into 'nazwa_repo'...
✓ Cloned to /home/user/nazwa_repo

# Lub standardowym git clone:
$ git clone https://github.com/twoj_login/nazwa_repo.git
⚠ Uwaga: gh auth login automatycznie ustawia credential.helper na swój własny helper. Git będzie używał tokena zarządzanego przez gh. Nie musisz wpisywać loginu ani hasła.
✅ Gotowe!
Jesteś zalogowany i możesz pracować z GitHub bezpośrednio z konsoli.

GitHub CLI integruje się z systemowym credential helperem Gita. Po zalogowaniu przez gh auth login w pliku ~/.gitconfig pojawia się wpis: [credential] helper = C:/Program Files/Git/mingw64/bin/git-credential-manager.exe (Windows) lub odpowiednio dla systemów Unix. Dzięki temu wszystkie operacje Git przez HTTPS będą automatycznie używać tokena wygenerowanego przez gh, bez potrzeby ręcznego wpisywania jakichkolwiek danych. Możesz również używać gh pr create, gh issue list i wielu innych komend do zarządzania projektem bez opuszczania terminala.

9/22
Metoda 2: Klucze SSH – Wprowadzenie
  • SSH (Secure Shell) to protokół kryptograficzny do bezpiecznej komunikacji.
  • GitHub umożliwia uwierzytelnianie przez klucz publiczny SSH – raz skonfigurowane działa bez haseł.
  • Działa to na zasadzie pary kluczy: prywatny (zostaje na Twoim komputerze) i publiczny (dodajesz do GitHub).
  • Podczas pusha Git podpisuje żądanie Twoim kluczem prywatnym – GitHub weryfikuje kluczem publicznym.
  • Metoda ta nie wymaga żadnych dodatkowych narzędzi – Git ma wbudowaną obsługę SSH.
  • Jest to najczęściej wybierana metoda przez doświadczonych użytkowników Linuksa.
🔒 Klucz prywatny
~/.ssh/id_ed25519

🔓 Klucz publiczny
~/.ssh/id_ed25519.pub

→ GitHub.com (Settings > SSH Keys)

Protokół SSH został opracowany w 1995 roku jako następca Telnetu i od tego czasu stał się standardem bezpiecznego zdalnego dostępu do systemów Unix. W kontekście Gita SSH jest używany jako transparentna warstwa transportowa – Git po prostu uruchamia klienta SSH, który nawiązuje zaszyfrowane połączenie z serwerem GitHub. Klucze kryptograficzne używane w SSH są praktycznie niemożliwe do złamania przy obecnej mocy obliczeniowej (klucz Ed25519 oferuje około 128 bitów bezpieczeństwa, co odpowiada kluczowi RSA 3072). Zaleca się używanie algorytmu Ed25519 zamiast starszego RSA, ponieważ jest szybszy i bezpieczniejszy.

10/22
Metoda 2: Generowanie klucza SSH
  • Otwórz terminal i wpisz poniższe polecenie (zastąp e-mail swoim adresem z GitHub):
$ ssh-keygen -t ed25519 -C "twoj_email@example.com"
  • Kreator zapyta o lokalizację zapisu klucza – naciśnij Enter, aby zaakceptować domyślną:
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/user/.ssh/id_ed25519): [Enter]
  • Następnie możesz ustawić hasło (passphrase) do klucza – zalecane, ale nieobowiązkowe:
Enter passphrase (empty for no passphrase): [Enter – brak hasła lub wpisz hasło]
Enter same passphrase again: [Enter]
Your identification has been saved in /home/user/.ssh/id_ed25519
Your public key has been saved in /home/user/.ssh/id_ed25519.pub
$ ssh-keygen -t ed25519 -C "student@example.com"

+--[ED25519 256]--+
| .o+.. . . . |
|. + =o.o o . |
| o + B.= = . |
| . = O.o + |
| . *oS+ . |
| o o=o . |
| .o=E. |
+----[SHA256]-----+

Polecenie ssh-keygen -t ed25519 -C "twoj_email@example.com" generuje parę kluczy z użyciem algorytmu krzywej eliptycznej Ed25519, który jest obecnie rekomendowany przez wszystkich głównych dostawców (GitHub, GitLab, AWS). Flaga -C dodaje komentarz do klucza (zazwyczaj adres e-mail), co ułatwia identyfikację klucza na liście w ustawieniach GitHub. Jeśli Twój system nie wspiera Ed25519 (bardzo stare dystrybucje), możesz użyć RSA: ssh-keygen -t rsa -b 4096 -C "twoj_email@example.com". Pliki kluczy są domyślnie zapisywane w katalogu ~/.ssh/ z uprawnieniami 600 dla klucza prywatnego i 644 dla publicznego.

11/22
Metoda 2: Uruchamianie agenta SSH
  • Agent SSH to program, który przechowuje odblokowane klucze w pamięci, aby nie wpisywać hasła (passphrase) przy każdym użyciu.
  • W Debianie agent SSH jest automatycznie uruchamiany przy logowaniu do sesji graficznej.
  • Jeśli pracujesz w czystym terminalu (bez sesji graficznej), uruchom agenta ręcznie:
$ eval "$(ssh-agent -s)"
Agent pid 12345
  • Dodaj swój klucz prywatny do agenta:
$ ssh-add ~/.ssh/id_ed25519
Identity added: /home/user/.ssh/id_ed25519 (twoj_email@example.com)
ℹ Bez hasła (passphrase): Jeśli pominąłeś ustawienie passphrase podczas generowania klucza, agent nie jest potrzebny – klucz jest gotowy do użycia od razu.
🖥 Automatyczne uruchamianie agenta:
W Debianie z sesją graficzną agent SSH startuje automatycznie. Sprawdź:
echo $SSH_AUTH_SOCK
Jeśli zwraca ścieżkę (np. /tmp/ssh-xxx/agent.xx) – agent działa.

Agent SSH to demon działający w tle, który przechowuje odszyfrowane klucze prywatne w pamięci operacyjnej. Gdy Git próbuje nawiązać połączenie SSH z GitHub, agent automatycznie podpisuje żądanie odpowiednim kluczem bez interakcji z użytkownikiem. Na systemach z sesją graficzną (GNOME, KDE, XFCE) agent SSH jest uruchamiany automatycznie przez menedżera logowania. W czystej konsoli (np. po ssh na serwer) trzeba go uruchomić ręcznie. Komenda ssh-add -l wyświetla listę kluczy aktualnie załadowanych do agenta. Aby trwale dodać klucz do agenta przy każdym logowaniu, dodaj ssh-add ~/.ssh/id_ed25519 do pliku ~/.bash_profile lub ~/.profile.

12/22
Metoda 2: Kopiowanie klucza publicznego
  • Wyświetl zawartość klucza publicznego w terminalu:
$ cat ~/.ssh/id_ed25519.pub
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIGpZ0...
  • Zaznacz cały tekst od ssh-ed25519 do końca (łącznie z e-mailem) i skopiuj.
  • Alternatywnie, użyj polecenia, które kopiuje bezpośrednio do schowka (wymaga xclip):
# Zainstaluj xclip (jeśli nie masz):
$ sudo apt install xclip

# Skopiuj klucz do schowka:
$ xclip -sel clip < ~/.ssh/id_ed25519.pub
⚠ Uwaga: Kopiujemy klucz publiczny (z rozszerzeniem .pub). Klucz prywatny (id_ed25519 – bez rozszerzenia) nigdy nie powinien opuścić Twojego komputera!
$ cat ~/.ssh/id_ed25519.pub

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIGpZ0Hh6UNjhCgKJqF3nVq0S2XpY7xwR8fL9kDvWm student@example.com

Klucz publiczny SSH to plik tekstowy, który można bezpiecznie udostępniać. Jego zawartość składa się z trzech elementów: typu klucza (ssh-ed25519), zakodowanego base64 klucza publicznego oraz komentarza (adres e-mail). GitHub używa tego klucza do weryfikacji Twojej tożsamości – gdy łączysz się przez SSH, GitHub szyfruje wiadomość Twoim kluczem publicznym, a Twój klient SSH musi ją odszyfrować kluczem prywatnym. Jeśli odszyfrowanie się powiedzie, GitHub wie, że masz dostęp do klucza prywatnego i autoryzuje połączenie. Nigdy nie dodawaj klucza prywatnego do GitHub ani nie przesyłaj go przez niezaszyfrowane kanały.

13/22
Metoda 2: Dodawanie klucza do GitHub
  • Zaloguj się na GitHub w przeglądarce i wykonaj następujące kroki:
📝 Instrukcja krok po kroku:
  1. Kliknij swój avatar (zdjęcie profilowe) w prawym górnym rogu → Settings
  2. W menu po lewej stronie kliknij SSH and GPG keys
  3. Kliknij zielony przycisk New SSH key
  4. W polu Title wpisz nazwę (np. "Laptop Debian")
  5. W polu Key wklej skopiowany wcześniej klucz publiczny (cała linia)
  6. Kliknij Add SSH key
ℹ Key type: Upewnij się, że na górze strony SSH Keys masz wybraną opcję Authentication Key (nie Signing Key, chyba że chcesz podpisywać commity).
🔐 SSH Keys / Add new
Title
Laptop Debian
Key
ssh-ed25519 AAAAC3NzaC1lZDI1...
Add SSH key

Po dodaniu klucza SSH do GitHub warto od razu go przetestować. GitHub pozwala na dodanie wielu kluczy – każde urządzenie powinno mieć własny, osobny klucz. Jeśli zmieniasz komputer lub formatujesz dysk, wygeneruj nowy klucz i dodaj go, a stary usuń z poziomu GitHub Settings. Dzięki temu w przypadku kradzieży lub zgubienia komputera możesz natychmiast unieważnić dostęp, usuwając odpowiedni klucz z GitHub. W ustawieniach SSH Keys zobaczysz listę wszystkich dodanych kluczy z datą dodania i informacją, kiedy były ostatnio używane.

14/22
Metoda 2: Test połączenia SSH
  • Po dodaniu klucza do GitHub sprawdź, czy połączenie działa:
$ ssh -T git@github.com
  • Poprawna odpowiedź (jeśli łączysz się pierwszy raz, potwierdź autentyczność hosta wpisując yes):
The authenticity of host 'github.com (140.82.121.3)' can't be established.
ED25519 key fingerprint is SHA256:+DiY3wvvV6TuJJhbpZisF/zLDA0zPMSvHdkr4UvCOqU.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Hi twoj_login! You've successfully authenticated, but GitHub does not provide shell access.
⚠ Ważne: Jeśli zobaczysz komunikat "Permission denied (publickey)", oznacza to, że GitHub nie rozpoznał Twojego klucza. Sprawdź, czy dodałeś klucz publiczny (.pub) na stronie GitHub i czy agent SSH ma załadowany właściwy klucz.
Hi twoj_login! You've successfully authenticated
GitHub does not provide shell access

Komenda ssh -T git@github.com próbuje nawiązać połączenie SSH z GitHub przy użyciu uwierzytelniania kluczem publicznym. Flaga -T wyłącza przydzielanie pseudoterminala (TTY), ponieważ nie będziemy wykonywać komend na serwerze – chcemy tylko sprawdzić autoryzację. Przy pierwszym połączeniu z GitHub z danego komputera SSH poprosi o potwierdzenie odcisku klucza hosta (host key fingerprint). Jest to mechanizm bezpieczeństwa chroniący przed atakami man-in-the-middle. Odciski palców GitHub są publicznie dostępne w dokumentacji: SHA256:+DiY3wvvV6TuJJhbpZisF/zLDA0zPMSvHdkr4UvCOqU (dla klucza ED25519 hosta). Po potwierdzeniu host jest zapisywany w pliku ~/.ssh/known_hosts.

15/22
Metoda 2: Klonowanie i push przez SSH
  • Aby używać SSH, musisz klonować repozytoria za pomocą adresu SSH (zaczynającego się od git@github.com:), a nie HTTPS.
  • Adres SSH znajdziesz na stronie repozytorium, klikając zielony przycisk Code i wybierając zakładkę SSH.
# Klonowanie przez SSH:
$ git clone git@github.com:twoj_login/nazwa_repo.git
Cloning into 'nazwa_repo'...
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
Receiving objects: 100% (5/5), done.
  • Po zmodyfikowaniu plików wykonaj standardowy push:
$ git add .
$ git commit -m "Moja zmiana"
$ git push
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Writing objects: 100% (3/3), 300 bytes | 300.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To github.com:twoj_login/nazwa_repo.git
a1b2c3d..e4f5g6h main -> main
📦 Code > Clone
HTTPS SSH GitHub CLI
git@github.com:twoj_login/nazwa_repo.git

Adres SSH do repozytorium ma format git@github.com:użytkownik/nazwa_repo.git. Jeśli sklonowałeś repozytorium przez HTTPS, a chcesz przejść na SSH, możesz zmienić remote: git remote set-url origin git@github.com:twoj_login/nazwa_repo.git. Komenda git remote -v pokaże aktualne adresy remote'ów. Po przejściu na SSH push i pull działają bez pytania o login i hasło – GitHub weryfikuje Cię na podstawie klucza SSH. W przypadku problemów z autoryzacją SSH warto sprawdzić: czy agent SSH działa (ssh-add -l), czy klucz jest załadowany oraz czy plik ~/.ssh/config nie blokuje połączenia.

16/22
Metoda 3: Personal Access Token (PAT) – Wprowadzenie
  • Personal Access Token (PAT) to wygenerowany przez GitHub ciąg znaków, który zastępuje hasło.
  • Działa przez protokół HTTPS – klasyczne git clone, push, pull z loginem i tokenem w miejsce hasła.
  • Możesz określić zakres uprawnień tokena (np. tylko do odczytu repozytoriów) i datę ważności.
  • Token jest jednorazowo wyświetlany przy generowaniu – jeśli go zgubisz, musisz wygenerować nowy.
  • Jest to metoda najbardziej zbliżona do starego logowania login+hasło.
  • Dobra opcja dla skryptów automatyzacji i CI/CD.
🔑 Token PAT
ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
→ używasz zamiast hasła

Personal Access Token to podstawowa metoda autoryzacji API GitHub, ale może być również używana jako alternatywa dla hasła w operacjach Git przez HTTPS. Tokeny PAT dzielą się na dwa typy: fine-grained tokens (dokładniejsze, nowsze, dostępne od 2022) oraz classic tokens (starsze, prostsze). Tokeny fine-grained pozwalają na precyzyjne określenie dostępu do konkretnych repozytoriów i zasobów, podczas gdy tokeny classic działają na poziomie konta. W obu przypadkach token jest 40-znakowym ciągiem zaczynającym się od ghp_ (dla classic) lub github_pat_ (dla fine-grained). Token nigdy nie jest przechowywany na serwerze GitHub po wygenerowaniu – jeśli go zgubisz, musisz utworzyć nowy.

17/22
Metoda 3: Generowanie tokena PAT (klasycznego)
  • Zaloguj się na GitHub w przeglądarce i wykonaj następujące kroki:
📝 Instrukcja krok po kroku:
  1. Kliknij swój avatar → Settings
  2. Na dole menu po lewej kliknij Developer settings
  3. Wybierz Personal access tokensTokens (classic)
  4. Kliknij Generate new tokenGenerate new token (classic)
  5. Wpisz nazwę (np. "Konsola Debian") i wybierz czas ważności (np. 90 dni)
  6. Zaznacz zakres repo (pełny dostęp do repozytoriów) oraz opcjonalnie workflow
  7. Kliknij Generate token na dole strony
  8. Natychmiast skopiuj token! Po zamknięciu strony nie zobaczysz go ponownie
⚙ New personal access token (classic)
Note
Konsola Debian
Expiration
90 days
Scopes
repo - Full control of private repositories
Generate token

Podczas generowania tokena PAT masz do wyboru wiele zakresów uprawnień (scopes): repo – pełny dostęp do repozytoriów (prywatnych i publicznych), workflow – dostęp do GitHub Actions, admin:repo_hook – zarządzanie webhookami, delete_repo – usuwanie repozytoriów, i wiele innych. Dla podstawowych operacji Git (clone, push, pull) wystarczy zakres repo. Jeśli zamierzasz używać tokena również do zarządzania GitHub Actions, dodaj workflow. Zasada najmniejszych uprawnień (principle of least privilege) mówi, aby nadawać tokenowi tylko te uprawnienia, które są niezbędne. Nie używaj tokena z pełnymi uprawnieniami do prostego klonowania publicznego repozytorium.

18/22
Metoda 3: Użycie PAT w konsoli
  • Podczas pierwszej operacji Git przez HTTPS, Git poprosi o login i hasło:
$ git clone https://github.com/twoj_login/nazwa_repo.git
Username for 'https://github.com': twoj_login
Password for 'https://twoj_login@github.com': [wklej token]
  • W polu Username wpisz swój login GitHub (nie e-mail).
  • W polu Password wklej token PAT (znaki nie będą widoczne podczas wklejania – to normalne).
  • Token zaczyna się od ghp_ (classic) lub github_pat_ (fine-grained).
⚠ Ważne: Jeśli używasz fine-grained tokena, musisz wyraźnie przyznać mu dostęp do konkretnych repozytoriów w ustawieniach tokena na GitHubie (Repository access > Only select repositories). Token classic z zakresem repo ma dostęp do wszystkich Twoich repozytoriów.
Username: jan_kowalski
Password: [wklej token – niewidoczny]

remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
Receiving objects: 100% (5/5), done.

Podczas wklejania tokena w terminalu systemy Unix/Linux domyślnie nie wyświetlają żadnych znaków (echo jest wyłączone dla pól hasła). Jest to celowe zachowanie bezpieczeństwa – nikt patrzący na ekran nie zobaczy długości ani fragmentu tokena. Po pomyślnym uwierzytelnieniu Git zapamiętuje token w pamięci (jeśli używasz credential helpera) lub prosi o niego przy każdej operacji. Token PAT jest przetwarzany jak zwykłe hasło, ale ma tę przewagę, że możesz go unieważnić w każdej chwili bez zmiany hasła do konta GitHub. Warto przechowywać token w menedżerze haseł (np. Bitwarden, KeePass) – nigdy nie zapisuj go w plikach tekstowych w repozytorium.

19/22
Metoda 3: Cache credential helper
  • Aby nie wklejać tokena przy każdej operacji, skonfiguruj cache poświadczeń Gita.
  • Git zapamięta token na określony czas w pamięci RAM:
# Zapamiętaj token na 1 godzinę (3600 sekund):
$ git config --global credential.helper 'cache --timeout=3600'
  • Po wpisaniu tokena raz, przez godzinę Git będzie używał go automatycznie.
  • Możesz ustawić dłuższy timeout, np. 8 godzin (28800 s) na cały dzień pracy:
$ git config --global credential.helper 'cache --timeout=28800'
ℹ Inne opcje: W Debianie możesz też skorzystać z libsecret – wymaga instalacji pakietów (sudo apt install libsecret-1-0 libsecret-1-dev), a następnie skompilowania pomocnika z katalogu /usr/share/doc/git/contrib/credential/libsecret/ (sudo make) i skonfigurowania go jako credential.helper. Dzięki temu token będzie przechowywany w systemowym magazynie haseł (GNOME Keyring/KDE Wallet).
⏱ Działanie cache:
git push → wpisz token → cache 3600s
git push (za 5 min) → cache działa → brak pytania
git push (za 2 godz.) → cache wygasł → wpisz token ponownie

Credential helper to mechanizm Gita umożliwiający przechowywanie i automatyczne dostarczanie poświadczeń (login + hasło/token) bez konieczności ręcznego wpisywania ich przy każdej operacji sieciowej. Git obsługuje kilka rodzajów credential helperów: cache – przechowuje poświadczenia w pamięci RAM (bezpieczne, ale ulotne), store – zapisuje poświadczenia w pliku tekstowym na dysku (wygodne, ale mniej bezpieczne), oraz zewnętrzne helpery systemowe, takie jak libsecret (GNOME Keyring), wincred (Windows Credential Manager) czy osxkeychain (macOS Keychain). W Debianie z sesją graficzną GNOME zalecany jest libsecret, który przechowuje token w zaszyfrowanym magazynie haseł.

20/22
Metoda 3: Przykład pełnego cyklu z PAT
  • Pełny przykład tworzenia nowego repozytorium i pushowania przez HTTPS z tokenem:
# 1. Utwórz nowe repozytorium na GitHub (przez przeglądarkę)
# 2. Zainicjuj lokalne repozytorium i dodaj plik:
$ mkdir test-push && cd test-push
$ git init
$ echo "# Test" > README.md
# 3. Dodaj remote (HTTPS):
$ git remote add origin https://github.com/twoj_login/test-push.git
# 4. Skonfiguruj cache na 1h i wykonaj push:
$ git config --global credential.helper 'cache --timeout=3600'
$ git add . && git commit -m "Pierwszy commit"
$ git push -u origin main
Username: twoj_login
Password: [wklej token PAT]
* [new branch] main -> main
Branch 'main' set up to track remote branch 'main'
✅ Push zakończony sukcesem!
Token został zapamiętany przez cache na 3600 sekund.

Po wykonaniu git push -u origin main z tokenem i skonfigurowanym credential helperem, Git zapisuje token w pamięci RAM. Flaga -u (lub --set-upstream) ustawia gałąź główną (upstream) dla bieżącej gałęzi, co pozwala od tego momentu wykonywać po prostu git push bez podawania nazwy remote'a i gałęzi. Pamiętaj, że cache credential helper jest ulotny – po wylogowaniu z sesji lub restarcie komputera token jest tracony i trzeba go wpisać ponownie. Jeśli chcesz trwale zapamiętać token, możesz użyć git config --global credential.helper store, ale jest to mniej bezpieczne, ponieważ token jest zapisywany w czystym tekście w pliku ~/.git-credentials.

21/22
Porównanie metod – kiedy którą wybrać?
KryteriumGitHub CLI (gh)SSHPAT (HTTPS)
Łatwość konfiguracji⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
Bezpieczeństwo⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐
Wymagane narzędziagh (dodatkowy pkg)wbudowane w Gitwbudowane w Git
Automatyzacja (CI/CD)❌ (interaktywny)✅ (deploy keys)✅ (secrets)
Działa bez internetu (przygotowanie)
Trwałość poświadczeńodświeżalny tokenbezterminowowymaga odświeżania
Dodatkowe funkcjeissue, PR, Actionstylko Gittylko Git
💡 Rekomendacja:
  • Student na zajęciach: GitHub CLI (gh) – najszybszy start
  • Codzienna praca na własnym PC: SSH – wygoda i bezpieczeństwo
  • Skrypty i CI/CD: PAT – łatwy do skonfigurowania jako secret
🎯
Cel: Bezproblemowa praca z GitHub
w konsoli Debian

Wybór odpowiedniej metody autoryzacji zależy od konkretnego scenariusza użycia. W laboratorium uczelnianym, gdzie studenci logują się na współdzielonych komputerach, najlepszym wyborem jest GitHub CLI – wystarczy gh auth login na początku zajęć, a token jest ważny przez całą sesję. W przypadku pracy na własnym laptopie SSH jest wygodniejsze, ponieważ klucze nie wygasają i nie wymagają ponownej konfiguracji przez lata. W środowiskach CI/CD (GitHub Actions, Jenkins) standardem są tokeny PAT przechowywane jako secrets w repozytorium. Niezależnie od metody, wszystkie trzy są bezpieczne i oficjalnie wspierane przez GitHub. Warto znać każdą z nich, aby móc elastycznie dostosować się do wymagań projektu.

22/22
Podsumowanie – co musisz zapamiętać?
  • Od sierpnia 2021 GitHub nie akceptuje haseł w konsoli – musisz użyć tokena lub SSH.
  • Masz do wyboru trzy bezpieczne metody: GitHub CLI, SSH, PAT.
  • GitHub CLI (gh): sudo apt install ghgh auth login – najprostsza metoda.
  • SSH: ssh-keygen -t ed25519 → dodaj klucz do GitHub → git clone git@github.com:...
  • PAT: Settings > Developer settings > Generate token → użyj zamiast hasła przez HTTPS.
  • Skonfiguruj credential.helper, aby nie wpisywać tokena przy każdej operacji.
  • Nigdy nie przechowuj tokenów ani kluczy prywatnych w repozytorium Git.
  • Regularnie odnawiaj tokeny PAT i usuwaj nieużywane klucze SSH z konta GitHub.
🎓 Git i GitHub to niezbędne narzędzia w pracy każdego programisty.
Opanowanie autoryzacji w konsoli to pierwszy krok do profesjonalnej pracy z kodem.

Znajomość metod autoryzacji do GitHub z poziomu konsoli jest kluczowa dla każdego studenta informatyki i programisty. W trakcie tego wykładu poznałeś trzy niezależne metody, z których każda ma swoje zalety i zastosowania. Ćwicz je wszystkie na swoim koncie GitHub – utwórz testowe repozytorium i wypróbuj każdą metodę od początku do końca. Pamiętaj, że w przypadku problemów GitHub oferuje doskonałą dokumentację, a społeczność programistów na Stack Overflow i forach dyskusyjnych zawsze chętnie pomaga. Powodzenia w dalszej pracy z Gitem i GitHub!