Что такое OAuth и каковы его основные принципы?

А, ОAuth, ёпта, классика жанра! Слушай, сейчас я тебе это так разложу, что ты поймёшь, даже если у тебя в голове вместо мозгов — хуй с винтом.

Представь себе, что ты — владелец ресурса. То есть, ты, сука, царь и бог своих данных. Сидишь ты такой на своём троне из фоток в инсте и переписок, а тут приходит какое-то левое приложение и говорит: «Дай доступ к твоим гитовским репозиториям, я тебе красивые графики нарисую».

Раньше бы ты, как лох, просто отдал бы им логин и пароль. А они бы потом могли делать что угодно: хоть коммиты от твоего имени в продакшн в три часа ночи лепить, хоть рассылать спам всем твоим коллегам. Пиздец, а не безопасность.

Так вот, ОAuth — это как раз про то, чтобы не отдавать пароль. Это как если бы ты не давал соседу ключи от всей квартиры, а выдал бы ему одноразовый пропуск только в туалет, и то на 15 минут. Гениально, блядь!

Кто тут главные по тарелкам:

1. Владелец ресурса (Resource Owner) — это ты, пизда бородавчатая, со своими данными.
2. Клиент (Client) — это та самая мартышлюшка-приложение, которое выпрашивает доступ.
3. Сервер авторизации (Authorization Server) — это большой брат, типа Google или GitHub. Он тебя узнаёт, спрашивает: «Ты точно хочешь дать доступ этому пидарасу?», и если ты киваешь, то выдаёт специальную бумажку (токен).
4. Сервер ресурсов (Resource Server) — это сейф, где лежат твои данные. Он не пускает никого, кроме тех, у кого есть правильная бумажка от Большого Брата.

Как это выглядит в жизни (самый правильный способ, Authorization Code Flow):

1. Ты в приложении жмёшь кнопку «Войти через GitHub». В этот момент приложение, хитрая жопа, говорит твоему браузеру: «Слушай, сгоняй-ка к Гитхабу, скажи, что я вот такой-сякой (Client ID) и хочу вот это (Scopes)».
2. Браузер прибегает к Гитхабу. Гитхаб тебе показывает: «Э, сабака, сука! Приложение «Говнографик 3000» хочет доступ к твоим репозиториям и почте. Пускать?». Ты, такой доверчивый, говоришь «Ага».
3. Гитхаб берёт и пишет на бумажке волшебный код (authorization code). И говорит браузеру: «На, отнеси это обратно тому приложению, по адресу, который оно указало (Redirect URI). И скажи, что state у нас random-state-string, всё чётко».
4. Браузер приносит код приложению. Вот тут внимание, ебать мои старые костыли! Приложение не использует этот код сам по себе. Оно берёт его, вместе со своим секретным паролем (Client Secret), который никто не должен видеть, и напрямую, с сервера на сервер, шепчет Гитхабу: «На, код, дай мне нормальный токен».
5. Гитхаб проверяет, что код живой, а секретный пароль верный, и выдаёт два токена:
   • Access Token — это пропуск в сейф. Живёт недолго, час-два.
   • Refresh Token — это бумажка, по которой можно получить новый пропуск, когда старый сдохнет. Хранится приложением в надёжном месте.
6. Всё! Теперь приложение может ходить к API Гитхаба (Resource Server), показывать токен и говорить: «Эй, дай-ка мне репозитории того чувака». API видит подпись Гитхаба на токене и выдаёт данные. И ни один пароль не пострадал! Удивление пиздец, да?

Вот как это на Go выглядит, с библиотекой golang.org/x/oauth2:

package main

import (
    "context"
    "fmt"
    "golang.org/x/oauth2"
    "golang.org/x/oauth2/github"
    "log"
    "net/http"
)

var oauthConf = &oauth2.Config{
    ClientID:     "TVOJ_CLIENT_ID", // Меняй, мудак, на свой!
    ClientSecret: "TVOJ_CLIENT_SECRET", // Это вообще никому не показывай, а то выебут!
    Scopes:       []string{"user:email", "repo"}, // Что просим: почту и репы
    Endpoint:     github.Endpoint, // Точки входа Гитхаба
    RedirectURL:  "http://localhost:8080/oauth/callback", // Куда Гитхаб будет стучаться назад
}

func main() {
    // 1. Кнопка "Логин"
    http.HandleFunc("/login", func(w http.ResponseWriter, r *http.Request) {
        // 'state' — это как печать на документе, чтобы подделок не было. Генерируй каждый раз новую!
        url := oauthConf.AuthCodeURL("random-state-string", oauth2.AccessTypeOffline)
        http.Redirect(w, r, url, http.StatusTemporaryRedirect)
    })

    // 2. Точка, куда Гитхаб вернётся с кодом
    http.HandleFunc("/oauth/callback", func(w http.ResponseWriter, r *http.Request) {
        // ПРОВЕРЯЙ STATE, БЛЯДЬ! Иначе тебя могут выебать CSRF-атакой!
        if r.FormValue("state") != "random-state-string" {
            log.Printf("Invalid state: %sn", r.FormValue("state"))
            http.Error(w, "State mismatch", http.StatusUnauthorized)
            return
        }

        // Меняем временный код на долгоиграющие токены
        code := r.FormValue("code")
        token, err := oauthConf.Exchange(context.Background(), code)
        if err != nil {
            log.Printf("Code exchange failed: %sn", err.Error())
            http.Error(w, "Could not get token", http.StatusInternalServerError)
            return
        }

        // Всё, токены в кармане! access_token — для API, refresh_token — про запас.
        fmt.Fprintf(w, "Access Token: %sn", token.AccessToken)
        fmt.Fprintf(w, "Refresh Token: %sn", token.RefreshToken)
    })

    fmt.Println("Server started on :8080. Visit http://localhost:8080/login")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Какие ещё бывают потоки (Grant Types), чтоб ты знал:

• Authorization Code Flow (с PKCE): Царь-поток для мобилок и одностраничников. Самый безопасный.
• Client Credentials Flow: Когда два сервиса между собой общаются, а пользователя — нихуя. Типа, твой микросервис дергает API другого микросервиса.
• Device Authorization Flow: Для этих ваших умных холодильников и телевизоров, где ввести пароль — та ещё пиздобратия.
• Implicit Flow: УСТАРЕВШИЙ, НЕ ИСПОЛЬЗУЙ! Токен сразу в URL летит — это как нести зарплату по тёмной улице, размахивая купюрами.
• Resource Owner Password Credentials Flow: ТОЖЕ НЕ ИСПОЛЬЗУЙ! Это когда приложение просит у тебя логин и пароль напрямую. Доверия к такому — ебать ноль. Это шаг назад, в каменный век.

Запомни главное: никому не свети Client Secret, всегда проверяй state и используй HTTPS. И тогда твоя авторизация будет не просто ОAuth, а О-хуенно-auth! В рот меня чих-пых, вот и вся наука.