├── .gitignore
├── LICENSE
├── Procfile
├── README.md
├── backend
├── facebook.go
├── github.go
├── google.go
└── option.go
├── bin
└── main
├── frontend
├── Islogin
│ └── index.html
├── img
│ ├── facebook.svg
│ ├── github.svg
│ └── google.svg
└── login
│ └── index.html
├── go.mod
├── go.sum
├── main.go
└── oauth.sh
/.gitignore:
--------------------------------------------------------------------------------
1 | # Binaries for programs and plugins
2 | *.dll
3 | *.so
4 | *.dylib
5 |
6 | # Test binary, built with `go test -c`
7 | *.test
8 |
9 | # Output of the go coverage tool, specifically when used with LiteIDE
10 | *.out
11 |
12 | # Dependency directories (remove the comment below to include it)
13 | # vendor/
14 |
15 | .env
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2020 davidleitw
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/Procfile:
--------------------------------------------------------------------------------
1 | web: bin/main
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # gin-oauth2-example
2 |
3 | ## a simple example use gin framework to login with oauth2.
4 |
5 | **此專案基於 golang.org/x/oauth2 來實作一個簡單的第三方登入系統，串接google, facebook, 以及github。**
6 |
7 | **[Demo](https://ginoauth-example.herokuapp.com/login) 網址，僅要求最低權限，提供email以及username。**
8 |
9 | 以下會依照個人理解以及網路上心得文章的整理，做一些簡單的觀念介紹。
10 |
11 | - # Oauth
12 |
13 | - ## 使用場景，為什麼我們要使用Oauth2?
14 | 假設今天我們要開發一個應用程式，功能是可以將使用者存在google帳號底下的照片都匯入應用程式並且做一些處理，這時候就要想說，我們的應用程式要怎麼存取到使用者帳號底下的資源呢？
15 |
16 |
17 | 在以前我們可能會想說，使用者自行輸入他的google帳號密碼，我們開發的應用程式再藉由那組帳號密碼獲得存取照片的權限，藉此來對照片進行處理。 但是這樣會衍生出很多問題，主要就是如果該應用程式是藉由我們使用者的google帳號密碼來獲得權限的話，應用程式本身獲得的權限太多了，應用程式本來只需要照片的存取權而已，如果是拿google帳密的話則是拿到了整個帳號的使用權限。
18 |
19 |
20 | 如果現在有個不懷好意的應用程式獲得了你整個google帳號密碼的使用權限， 便可以透過它去登入很多不同的網站，又或者是拿去做非法的交易等等... 所以需要提出一個解決方法，一來是可以讓應用程式獲得他想要獲得的資源，二來是也不會開放太多的權限給應用程 式，只授權部份的存取功能。
21 |
22 |
23 | 從另外一個角度來討論， 如果今天我很信任這個應用程式，把整個帳號的權限都交給了這個應用程式， 某一天決定之後可能不再使用這個應用程式了。 這時候我們如果想要把權限收回來怎麼做呢? 我們需要把帳號密碼重新設定一輪，才可以確保應用程式本身不再有獲得我帳號權限的能力。
24 |
25 |
26 | ### 總結一下傳統方法的缺點:
27 | (1) 應用程式為了後續的操作可能會保留使用者的帳號密碼， 我們無法確定是否安全。
28 | (2) 使用者無法限制應用程式能掌握到的權限，以及權限有效的時間。
29 | (3) 修改密碼之後可以收回權限，不過也同時讓所有獲得用戶授權的第三方應用全部失效。
30 | (4) 只要有一個第三方的應用程式出現了資料外洩問題，會導致其他第三方應用也有被盜用的危險。
31 |
32 |
33 |
34 | > **簡單的說Oauth就是一種授權機制，以google為存放data的地方為例， 使用者告知google，授權第三方的應用程式可以獲得部份的資源， google的系統則產生一個token， 第三方的應用可以透過token來在實現內進行授權權限內的資料存取。**
35 |
36 |
37 | > **Token vs PassWord**
38 | > **(1) token是有時效性，時間到了會自動撤銷，不會讓第三方應用程式一直持有權限。**
39 | > **(2) 如果今天不想要繼續授權給應用程式了，資源擁有者可以隨時撤銷token的有效性。**
40 | > **(3) token最大的好處是有權限的管理，可以只開放部份的資源存取權給第三方的應用程式。**
41 |
42 | - ## Oauth2.0規格書 [RFC6749](https://tools.ietf.org/html/rfc6749)
43 | 這份規格書內清楚的寫了Oauth2.0的設計準則， 如果想要清楚的知道oauth2.0底層是如何運作的可以參考看看。
44 | 值得注意的是在RFC 6749的文件內清楚的說明了Oauth2.0的角色
45 | > **Oauth在傳統的架構上引入了一層授權層，用以分隔客戶端以及資源擁有者，當資源的擁有者授權客戶端(第三方應用程式)應用可以存取資源的時候，用來存放資源的伺服器會頒發一個Access Token給客戶端(第三方應用程式)， 客戶端拿到Token之後就可以藉由此Token對資源做有限度的存取(並沒有拿到全部的權限)。**
46 |
47 | > 原文段落:
48 | >
49 | > The OAuth 2.0 authorization framework enables a third-party application to obtain limited access to an HTTP service, either on behalf of a resource owner by orchestrating an approval interaction between the resource owner and the HTTP service, or by allowing the third-party application to obtain access on its own behalf. This specification replaces and obsoletes the OAuth 1.0 protocol described in RFC 5849.
50 |
51 |
52 |
53 | 由上面那段重點可以得知Oauth扮演的核心角色就是向第三方應用程式頒發Token，作為第三方應用跟資源網站的橋樑。
54 |
55 |
56 | > **補充: [RFC6750](https://tools.ietf.org/html/rfc6750) 該文件敘述一些有關於Token實作上的細節**
57 |
58 | - ## Authorization Grant(四種獲得Token的方式)
59 | > #### 1. **authorization-code (授權碼)**
60 | > #### 2. **implicit (隱藏式)**
61 | > #### 3. **password (密碼式)**
62 | > #### 4. **client credentials (客戶端憑證)**
63 |
64 | 接著就依序介紹一下這四種獲得Token的方式個別用在哪種場景，以及需要注意的地方。
65 |
66 |
67 | - ### Authorization-Code(授權碼):
68 | **此範例就是使用Authorization Code的方法去實行的。**
69 |
70 |
71 | 此方法是目前最為常見的一種手法，在主流的前後端分離架構上，通常採取這種方法，使得可以在**後端獲得Token**，所有有關於資源存取的運算都放在後端， 可以減少token暴露的機會。
72 |
73 |
74 | 通常如果是使用這種驗證方法的話，需要先去跟資源擁有者申請**ClientID**跟**ClientSecret**。
75 | 藉由ClientID，資源擁有者(ex: google)才知道今天是哪個第三方應用在請求資源。
76 |
77 |
78 | 大致流程如下圖所示 [來源](https://itnext.io/an-oauth-2-0-introduction-for-beginners-6e386b19f7a9)
79 | 
80 |
81 |
82 | 以下解說皆以此專案Demo的網址作為範例， 可以與[Demo](https://ginoauth-example.herokuapp.com/login)一起服用。
83 | 一開始我們點進去的網址是**https://ginoauth-example.herokuapp.com/login**
84 |
85 | 今天用戶想要以google帳號登入我們的第三方應用(A)， 所以點了google登入的按鍵。
86 |
87 | 按下去之後會跳轉到以下網址(範例，僅列出常見的參數)
88 | > https://accounts.google.com/o/oauth2/auth/identifier?
89 | > client_id=xxx&
90 | > response_type=code&
91 | > redirect_url=https://ginoauth-example.herokuapp.com/callback/google&
92 | > scope=https://www.googleapis.com/auth/userinfo.profile&
93 | > state=xxxx
94 |
95 | 參數說明
96 | > - cliend_id: 填入第三方程式申請oauth服務時獲得的ID，主要目的是讓google知道是誰在申請。
97 | > - response_type: 參數代表目前申請token採用的是哪一種方式， 這邊填入"code"，代表要申請授權碼。
98 | > - redirect_url: 參數代表如果google接受請求之後會跳轉的界面。
99 | > - scope: 參數是代表這次第三方應用申請oauth之後供存取的權限(授權範圍)。
100 | > - state: 防止CSRF攻擊
101 |
102 | 跳轉後由user輸入帳號密碼，告知google授權資源存取權給A。(授權的範圍就是scope中所指定的資源)
103 | google確認user同意之後會將網頁跳轉到上方redirect_url參數中所指定的url。
104 | > https://ginoauth-example.herokuapp.com/callback/google?state=xxxx&code=@#!@%!%!
105 |
106 |
107 | 跳轉到callback，同時會將state跟authorization code加入跳轉url的query string之中。
108 | 其中state參數必須跟第一步驟跳轉到google時填入的state參數相同，避免CSRF攻擊。
109 | 通常state會存在session內，以便於比對。
110 |
111 | > 詳情請參考[OAuth 2.0 筆記 (7) 安全性問題](https://blog.yorkxin.org/2013/09/30/oauth2-7-security-considerations.html)
112 |
113 |
114 | #### 藉由authorization code取得access code
115 | 再來談談code參數，後端跳轉到callback並且接受code之後，需要再以code參數去跟google拿Token。
116 | 再藉由Token去跟google獲得真正想要的資源。
117 |
118 | > 向google申請Access Token的url
119 | > https://oauth2.googleapis.com/token?client_id=xxx
120 | > &client_secret=xxxx
121 | > &authorization_code=xxxxx
122 | > &grant_type=code
123 |
124 | 參數說明
125 | > - client_id, client_secret: 讓google得知此次請求是由哪個第三方應用發送。
126 | > - authorization_code: 剛剛上方取得的授權碼。
127 | > - grant_type: 告知此次請求是採用Authorization-Code的方式進行。
128 |
129 | 回傳json形式範例(根據要求資源的公司不同，回傳的json格式會有些許落差。)
130 | ```json
131 | {
132 | "access_token": "xxxx",
133 | "token_type": "xxx",
134 | "expires_in": "放token過期時間",
135 | "refresh_token": "當access token過期時，可以再次申請一組Access Token",
136 | "scope": "權限",
137 | "uid": "xxxx",
138 | "info": "xxxx",
139 | }
140 | ```
141 |
142 | 最後就可以藉由上述流程中獲得的access_token來申請資源啦。
143 | 要注意的是**client_secret, access_token等資訊一定要放在後端並且小心存放避免暴露**。
144 |
145 | - ### Implicit(隱藏式):
146 |
147 | 這個方法現在已經比較少用了，應用場景主要是在沒有後端的純前端應用上。
148 |
149 | 直接將Access Token儲存在前端， 並且因為隱藏了授權碼的使用， 所以被稱為隱藏式。
150 |
151 | 由於此方法非常的不安全， 會將Access Token暴露在前端， 所以通常只能用在安全需求低的場景， 而且對於Token的有效時間要設置的非常短， 避免有心人士利用。
152 |
153 | 通過這個方式得到授權之後，google會根據申請時候的redirect參數去跳轉。 範例如下
154 | > https://test.com/callback#token=Access_Token
155 |
156 | 值得注意的是回傳的Access_Token並不是放在Query_String中，而是放在了Fragment內， 這樣的好處是參數並不會傳回伺服器，而是僅供瀏覽器使用， 可以防止中間人攻擊的發生。
157 |
158 | 更多有關URL參數以及Fragment的細節可以參考: [URL](https://terrylee7788.wordpress.com/2015/07/11/url-%E7%9A%84%E5%90%84%E5%80%8B%E9%83%A8%E5%88%86/) [Wiki](https://en.wikipedia.org/wiki/URI_fragment)
159 |
160 | - ### Password(密碼式)
161 |
162 | 這種情境個人認為又更少使用了， 此認證方式只會出現在當使用者今天高度的信任某個第三方應用程式， RFC 6749也允許在此情況下直接將用戶google的帳號密碼告訴第三方的應用程式。
163 |
164 | 使用這種方式的時候Access_Token會直接以json的方式回傳給第三方的應用，此種方式通常較不推薦， 畢竟在網路的世界，還是要以安全為最高準則。
165 |
166 | - ### Client Credentials(憑證式)
167 |
168 | 最後一種認證方式我們稱之為憑證式，運用的場景就是今天的第三方應用並不存在前後端，而是在command底運行的應用程式，這種認證方式通常不是針對使用者，而是針對第三方應用程式量身打造的。
169 |
170 | 一般像是用在，例如我今天寫了一個應用程式需要接上youtube的API，這樣的話我就需要只用這種認證方式，讓youtube知道今天我的某個應用程式要存取youtube的資源。
171 |
172 | 我寫的應用程式存取到youtube的資源之後再給全部的使用者使用， 有點類似底下的使用者都可以共享我的應用程式所存取的資源。
173 |
174 | - ## 第三方登入流程簡述
175 |
176 | - 今天假設我們的第三方登入網站為A， 開放用戶藉由google帳號去做登入，流程大概如下:
177 |
178 | > A跳轉至google登入界面。
179 | > ↓
180 | > google要求用戶登入google帳號，並且詢問是否願意開放權限給A做使用。
181 | > ↓
182 | > 用戶同意開放權限，google再跳轉回A網站，並且在query string附上code。
183 | > ↓
184 | > A網站在後端使用code向google申請Access Token。
185 | > ↓
186 | > google將Access Token以及一些相關資訊放入json回傳。
187 | > ↓
188 | > A網站藉由Access Token向google請求相關的用戶資源。
189 |
190 | - ## Reference
191 | - [GitHub OAuth 第三方登入範例](http://www.ruanyifeng.com/blog/2019/04/github-oauth.html)
192 | - [Google Sign-in with OAuth 2.0](https://yushuanhsieh.github.io/post/2018-08-25-go-google-oauth/#comments)
193 | - [OAuth 2.0筆記系列](https://blog.yorkxin.org/2013/09/30/oauth2-4-1-auth-code-grant-flow.html)
194 | - [google oauth2](https://developers.google.com/identity/protocols/oauth2/web-server#httprest_7)
195 |
196 |
--------------------------------------------------------------------------------
/backend/facebook.go:
--------------------------------------------------------------------------------
1 | package backend
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "errors"
7 | "io/ioutil"
8 | "net/http"
9 | "net/url"
10 |
11 | "github.com/gin-contrib/sessions"
12 | "github.com/gin-gonic/gin"
13 | _ "github.com/joho/godotenv/autoload"
14 | "golang.org/x/oauth2"
15 | "golang.org/x/oauth2/facebook"
16 | )
17 |
18 | var facebook_config *oauth2.Config
19 |
20 | type facebookUser struct {
21 | ID string `json:"id"`
22 | Name string `json:"name"`
23 | Email string `json:"email"`
24 | }
25 |
26 | func getFacebookOauthURL() (*oauth2.Config, string) {
27 | options := CreateClientOptions("facebook", "https://ginoauth-example.herokuapp.com/callback/facebook")
28 |
29 | facebook_config = &oauth2.Config{
30 | ClientID: options.getID(),
31 | ClientSecret: options.getSecret(),
32 | RedirectURL: options.getRedirectURL(),
33 | Scopes: []string{
34 | "email",
35 | "public_profile",
36 | },
37 | Endpoint: facebook.Endpoint,
38 | }
39 | state := GenerateState()
40 | return facebook_config, state
41 | }
42 |
43 | func FacebookOauthLogin(ctx *gin.Context) {
44 | config, state := getFacebookOauthURL()
45 | redirectURL := config.AuthCodeURL(state)
46 |
47 | session := sessions.Default(ctx)
48 | session.Set("state", state)
49 | err := session.Save()
50 | if err != nil {
51 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
52 | return
53 | }
54 |
55 | ctx.Redirect(http.StatusSeeOther, redirectURL)
56 | }
57 |
58 | func FacebookCallBack(ctx *gin.Context) {
59 | if error_reason := ctx.Query("error_reason"); error_reason != "" {
60 | _ = ctx.AbortWithError(http.StatusUnauthorized, errors.New(error_reason))
61 | return
62 | }
63 |
64 | session := sessions.Default(ctx)
65 | state := session.Get("state")
66 | if state != ctx.Query("state") {
67 | _ = ctx.AbortWithError(http.StatusUnauthorized, StateError)
68 | return
69 | }
70 |
71 | code := ctx.Query("code")
72 | token, err := facebook_config.Exchange(ctx, code)
73 | if err != nil {
74 | _ = ctx.AbortWithError(http.StatusUnauthorized, err)
75 | return
76 | }
77 |
78 | client := facebook_config.Client(context.TODO(), token)
79 |
80 | userInfo, err := client.Get("https://graph.facebook.com/v8.0/me?fields=id,name,email")
81 | if err != nil {
82 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
83 | return
84 | }
85 |
86 | info, err := ioutil.ReadAll(userInfo.Body)
87 | if err != nil {
88 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
89 | return
90 | }
91 |
92 | var user facebookUser
93 | err = json.Unmarshal(info, &user)
94 | if err != nil {
95 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
96 | return
97 | }
98 |
99 | // redirect to islogin page, and add email, name into url's query string.
100 | redirectURL, err := url.Parse(IsLoginURL)
101 | if err != nil {
102 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
103 | return
104 | }
105 |
106 | query, err := url.ParseQuery(redirectURL.RawQuery)
107 | if err != nil {
108 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
109 | return
110 | }
111 |
112 | query.Add("email", user.Email)
113 | query.Add("name", user.Name)
114 | query.Add("source", "facebook")
115 | redirectURL.RawQuery = query.Encode()
116 |
117 | // 跳轉登入成功畫面(顯示登入資訊)
118 | ctx.Redirect(http.StatusSeeOther, redirectURL.String())
119 | }
120 |
--------------------------------------------------------------------------------
/backend/github.go:
--------------------------------------------------------------------------------
1 | package backend
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "io/ioutil"
7 | "net/http"
8 | "net/url"
9 |
10 | "github.com/gin-contrib/sessions"
11 | "github.com/gin-gonic/gin"
12 | _ "github.com/joho/godotenv/autoload"
13 | "golang.org/x/oauth2"
14 | "golang.org/x/oauth2/github"
15 | )
16 |
17 | var github_config *oauth2.Config
18 |
19 | type githubUser struct {
20 | Login string `json:"login"`
21 | ID int `json:"id"`
22 | NodeID string `json:"node_id"`
23 | AvatarURL string `json:"avatar_url"`
24 | GravatarID string `json:"gravatar_id"`
25 | URL string `json:"url"`
26 | HTML_URL string `json:"html_url"`
27 | FollowersURL string `json:"followers_url"`
28 | FollowingURL string `json:"following_url"`
29 | GistsURL string `json:"gists_url"`
30 | StarredURL string `json:"starred_url"`
31 | SubscriptionsURL string `json:"subscriptions_url"`
32 | OrganizationsURL string `json:"organizations_url"`
33 | ReposURL string `json:"repos_url"`
34 | EventsURL string `json:"events_url"`
35 | ReceivedEventsURL string `json:"received_events_url"`
36 | Type string `json:"type"`
37 | SiteAdmin bool `json:"site_admin"`
38 | Name string `json:"name"`
39 | Company string `json:"company"`
40 | Blog string `json:"blog"`
41 | Location string `json:"location"`
42 | Email string `json:"email"`
43 | Hireable bool `json:"hireable"`
44 | Bio string `json:"bio"`
45 | TwitterUserName string `json:"twitter_username"`
46 | PublicRepos int `json:"public_repos"`
47 | PublicGists int `json:"public_gits"`
48 | Followers int `json:"followers"`
49 | Following int `json:"following"`
50 | CreatedAt string `json:"created_at"`
51 | UpdatedAt string `json:"updated_at"`
52 | }
53 |
54 | func getGithubOauthURL() (*oauth2.Config, string) {
55 | options := CreateClientOptions("github", "https://ginoauth-example.herokuapp.com/callback/github")
56 |
57 | github_config = &oauth2.Config{
58 | ClientID: options.getID(),
59 | ClientSecret: options.getSecret(),
60 | RedirectURL: options.getRedirectURL(),
61 | Scopes: []string{
62 | "user",
63 | "repo",
64 | },
65 | Endpoint: github.Endpoint,
66 | }
67 |
68 | state := GenerateState()
69 | return github_config, state
70 | }
71 |
72 | func GithubOauthLogin(ctx *gin.Context) {
73 | config, state := getGithubOauthURL()
74 | redirectURL := config.AuthCodeURL(state)
75 |
76 | session := sessions.Default(ctx)
77 | session.Set("state", state)
78 | err := session.Save()
79 | if err != nil {
80 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
81 | return
82 | }
83 |
84 | ctx.Redirect(http.StatusSeeOther, redirectURL)
85 | }
86 |
87 | func GithubCallBack(ctx *gin.Context) {
88 | session := sessions.Default(ctx)
89 | state := session.Get("state")
90 | if state != ctx.Query("state") {
91 | _ = ctx.AbortWithError(http.StatusUnauthorized, StateError)
92 | return
93 | }
94 |
95 | code := ctx.Query("code")
96 | token, err := github_config.Exchange(ctx, code)
97 | if err != nil {
98 | _ = ctx.AbortWithError(http.StatusUnauthorized, err)
99 | return
100 | }
101 |
102 | client := github_config.Client(context.TODO(), token)
103 | userInfo, err := client.Get("https://api.github.com/user")
104 | if err != nil {
105 | _ = ctx.AbortWithError(http.StatusBadRequest, err)
106 | return
107 | }
108 | defer userInfo.Body.Close()
109 |
110 | info, err := ioutil.ReadAll(userInfo.Body)
111 | if err != nil {
112 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
113 | return
114 | }
115 |
116 | var user githubUser
117 | __debug__printJSON(info)
118 | err = json.Unmarshal(info, &user)
119 | if err != nil {
120 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
121 | return
122 | }
123 |
124 | // redirect to islogin page, and add email, name into url's query string.
125 | redirectURL, err := url.Parse(IsLoginURL)
126 | if err != nil {
127 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
128 | return
129 | }
130 |
131 | query, err := url.ParseQuery(redirectURL.RawQuery)
132 | if err != nil {
133 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
134 | return
135 | }
136 |
137 | query.Add("email", user.Email)
138 | query.Add("name", user.Name)
139 | query.Add("source", "github")
140 | redirectURL.RawQuery = query.Encode()
141 |
142 | // 跳轉登入成功畫面(顯示登入資訊)
143 | ctx.Redirect(http.StatusSeeOther, redirectURL.String())
144 | }
145 |
--------------------------------------------------------------------------------
/backend/google.go:
--------------------------------------------------------------------------------
1 | package backend
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "io/ioutil"
7 | "net/http"
8 | "net/url"
9 |
10 | "github.com/gin-contrib/sessions"
11 | "github.com/gin-gonic/gin"
12 | _ "github.com/joho/godotenv/autoload"
13 | "golang.org/x/oauth2"
14 | "golang.org/x/oauth2/google"
15 | )
16 |
17 | var google_config *oauth2.Config
18 |
19 | type googleUser struct {
20 | Sub string `json:"sub"`
21 | Name string `json:"name"`
22 | GivenName string `json:"given_name"`
23 | FamilyName string `json:"family_name"`
24 | Profile string `json:"profile"`
25 | Picture string `json:"picture"`
26 | Email string `json:"email"`
27 | EmailVerified bool `json:"email_verified"`
28 | Gender string `json:"gender"`
29 | Hd string `json:"hd"`
30 | }
31 |
32 | func getGoogleOauthURL() (*oauth2.Config, string) {
33 | options := CreateClientOptions("google", "https://ginoauth-example.herokuapp.com/callback/google")
34 |
35 | google_config = &oauth2.Config{
36 | ClientID: options.getID(),
37 | ClientSecret: options.getSecret(),
38 | RedirectURL: options.getRedirectURL(),
39 | Scopes: []string{
40 | "https://www.googleapis.com/auth/userinfo.email",
41 | "https://www.googleapis.com/auth/userinfo.profile",
42 | },
43 | Endpoint: google.Endpoint,
44 | }
45 |
46 | state := GenerateState()
47 | return google_config, state
48 | }
49 |
50 | func GoogleOauthLogin(ctx *gin.Context) {
51 | config, state := getGoogleOauthURL()
52 | redirectURL := config.AuthCodeURL(state)
53 |
54 | session := sessions.Default(ctx)
55 | session.Set("state", state)
56 | err := session.Save()
57 | if err != nil {
58 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
59 | return
60 | }
61 |
62 | ctx.Redirect(http.StatusSeeOther, redirectURL)
63 | }
64 |
65 | func GoogleCallBack(ctx *gin.Context) {
66 | session := sessions.Default(ctx)
67 | state := session.Get("state")
68 | if state != ctx.Query("state") {
69 | _ = ctx.AbortWithError(http.StatusUnauthorized, StateError)
70 | return
71 | }
72 |
73 | // 藉由Authorization Code去跟google(resource)申請Access Token
74 | code := ctx.Query("code")
75 | token, err := google_config.Exchange(ctx, code)
76 | if err != nil {
77 | _ = ctx.AbortWithError(http.StatusUnauthorized, err)
78 | return
79 | }
80 |
81 | // 藉由獲得的Access Token去跟google申請資源
82 | client := google_config.Client(context.TODO(), token)
83 | userInfo, err := client.Get("https://www.googleapis.com/oauth2/v3/userinfo")
84 | if err != nil {
85 | _ = ctx.AbortWithError(http.StatusBadRequest, err)
86 | return
87 | }
88 | defer userInfo.Body.Close()
89 |
90 | info, err := ioutil.ReadAll(userInfo.Body)
91 | if err != nil {
92 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
93 | return
94 | }
95 |
96 | var user googleUser
97 | err = json.Unmarshal(info, &user)
98 | if err != nil {
99 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
100 | return
101 | }
102 |
103 | // redirect to islogin page, and add email, name into url's query string.
104 | redirectURL, err := url.Parse(IsLoginURL)
105 | if err != nil {
106 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
107 | return
108 | }
109 |
110 | query, err := url.ParseQuery(redirectURL.RawQuery)
111 | if err != nil {
112 | _ = ctx.AbortWithError(http.StatusInternalServerError, err)
113 | return
114 | }
115 |
116 | query.Add("email", user.Email)
117 | query.Add("name", user.Name)
118 | query.Add("source", "google")
119 | redirectURL.RawQuery = query.Encode()
120 |
121 | // 跳轉登入成功畫面(顯示登入資訊)
122 | ctx.Redirect(http.StatusSeeOther, redirectURL.String())
123 | }
124 |
--------------------------------------------------------------------------------
/backend/option.go:
--------------------------------------------------------------------------------
1 | package backend
2 |
3 | import (
4 | "bytes"
5 | "encoding/json"
6 | "errors"
7 | "log"
8 | "os"
9 |
10 | "github.com/rs/xid"
11 | )
12 |
13 | var StateError = errors.New("state error.")
14 |
15 | const IsLoginURL = "/islogin" // "https://ginoauth-example.herokuapp.com/Islogin"
16 |
17 | type ClientOption struct {
18 | clientID string
19 | clientSecret string
20 | redirectURL string
21 | }
22 |
23 | func createClientOptions(company, redirectURL string) *ClientOption {
24 | var ID, Secret string
25 | switch company {
26 | case "google":
27 | ID = os.Getenv("GoogleID")
28 | Secret = os.Getenv("GoogleSecret")
29 | case "facebook":
30 | ID = os.Getenv("FacebookID")
31 | Secret = os.Getenv("FacebookSecret")
32 | case "github":
33 | ID = os.Getenv("GithubID")
34 | Secret = os.Getenv("GithubSecret")
35 | case "twitter":
36 | ID = os.Getenv("TwitterID")
37 | Secret = os.Getenv("TwitterSecret")
38 | default:
39 | ID = ""
40 | Secret = ""
41 | }
42 |
43 | return &ClientOption{
44 | clientID: ID,
45 | clientSecret: Secret,
46 | redirectURL: redirectURL,
47 | }
48 | }
49 |
50 | func CreateClientOptions(company string, redirectURL string) *ClientOption {
51 | return createClientOptions(company, redirectURL)
52 | }
53 |
54 | func CreateClientOptionsWithString(ID, Secret, RedirectURL string) *ClientOption {
55 | c := new(ClientOption)
56 | c.setID(ID)
57 | c.setSecret(Secret)
58 | c.setRedirectURL(RedirectURL)
59 | return c
60 | }
61 |
62 | func (c *ClientOption) setRedirectURL(URL string) {
63 | c.redirectURL = URL
64 | }
65 |
66 | func (c *ClientOption) setID(ID string) {
67 | c.clientID = ID
68 | }
69 |
70 | func (c *ClientOption) setSecret(Secret string) {
71 | c.clientSecret = Secret
72 | }
73 |
74 | func (c *ClientOption) getID() string {
75 | return c.clientID
76 | }
77 |
78 | func (c *ClientOption) getSecret() string {
79 | return c.clientSecret
80 | }
81 |
82 | func (c *ClientOption) getRedirectURL() string {
83 | return c.redirectURL
84 | }
85 |
86 | func GenerateState() string {
87 | return xid.New().String()
88 | }
89 |
90 | func __debug__printJSON(js []byte) {
91 | var prettyJSON bytes.Buffer
92 | err := json.Indent(&prettyJSON, js, "", "\n")
93 |
94 | result := string(prettyJSON.Bytes())
95 |
96 | if err == nil {
97 | log.Println(result)
98 | } else {
99 | log.Println("Println Json error = ", err)
100 | }
101 | }
102 |
--------------------------------------------------------------------------------
/bin/main:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/davidleitw/gin-oauth2-example/ca440b2e4b702a66414e8aa9d1ebf332616dc3f5/bin/main
--------------------------------------------------------------------------------
/frontend/Islogin/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | Document
8 |
41 |
42 |
43 |
44 |
45 |
帳戶資訊
46 |
47 |
test
48 |
49 |
50 |
xxxx@xxxx.com
51 |
52 |
53 |
從xxxx登入
54 |
55 |
106 | Google Login
107 |
108 |
109 | 
110 | Facebook Login
111 |
112 |
113 | 
114 | Github Login
115 |
116 |