forked from evcc-io/evcc
/
identity.go
142 lines (115 loc) · 3.2 KB
/
identity.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
package mb
import (
"context"
"crypto/rand"
"encoding/base64"
"fmt"
"io"
"net/http"
"net/http/cookiejar"
"net/url"
"strings"
"github.com/connectorjs/evcm/util"
"github.com/connectorjs/evcm/util/request"
"golang.org/x/net/publicsuffix"
"golang.org/x/oauth2"
)
// https://github.com/TA2k/ioBroker.smart-eq
// https://id.mercedes-benz.com/.well-known/openid-configuration
const OAuthURI = "https://id.mercedes-benz.com"
type Identity struct {
*request.Helper
oc *oauth2.Config
oauth2.TokenSource
}
// NewIdentity creates Mercedes Benz identity
func NewIdentity(log *util.Logger, oc *oauth2.Config) *Identity {
return &Identity{
Helper: request.NewHelper(log),
oc: oc,
}
}
// github.com/uhthomas/tesla
func state() string {
var b [9]byte
if _, err := io.ReadFull(rand.Reader, b[:]); err != nil {
panic(err)
}
return base64.RawURLEncoding.EncodeToString(b[:])
}
func (v *Identity) Login(user, password string) error {
if v.Client.Jar == nil {
v.Client.Jar, _ = cookiejar.New(&cookiejar.Options{
PublicSuffixList: publicsuffix.List,
})
}
var param request.InterceptResult
v.Client.CheckRedirect, param = request.InterceptRedirect("resume", false)
cv := oauth2.GenerateVerifier()
uri := v.oc.AuthCodeURL(state(), oauth2.AccessTypeOffline, oauth2.S256ChallengeOption(cv))
if _, err := v.Get(uri); err != nil {
return err
}
resume, err := param()
if err != nil {
return err
}
v.Client.CheckRedirect = nil
data := struct {
Username string `json:"username"`
Password string `json:"password,omitempty"`
RememberMe bool `json:"rememberMe,omitempty"`
}{
Username: user,
}
var res struct {
Result, Token string
Errors []struct{ Key string }
}
uri = fmt.Sprintf("%s/ciam/auth/login/user", OAuthURI)
req, err := request.New(http.MethodPost, uri, request.MarshalJSON(data), request.JSONEncoding)
if err == nil {
if err = v.DoJSON(req, &res); err != nil && len(res.Errors) > 0 {
err = fmt.Errorf("%s: %w", string(res.Errors[0].Key), err)
}
}
if err == nil {
data.Password = password
data.RememberMe = true
uri = fmt.Sprintf("%s/ciam/auth/login/pass", OAuthURI)
req, err = request.New(http.MethodPost, uri, request.MarshalJSON(data), request.JSONEncoding)
if err == nil {
if err = v.DoJSON(req, &res); err != nil && len(res.Errors) > 0 {
err = fmt.Errorf("%s: %w", string(res.Errors[0].Key), err)
}
}
}
if err == nil && res.Token == "" && res.Result != "" {
err = fmt.Errorf("missing token: %s", res.Result)
}
var code string
if err == nil {
params := url.Values{
"token": {res.Token},
}
var param request.InterceptResult
v.Client.CheckRedirect, param = request.InterceptRedirect("code", true)
uri := OAuthURI + resume
if _, err = v.Post(uri, request.FormContent, strings.NewReader(params.Encode())); err == nil {
code, err = param()
}
v.Client.CheckRedirect = nil
}
var token *oauth2.Token
if err == nil {
ctx, cancel := context.WithTimeout(
context.WithValue(context.Background(), oauth2.HTTPClient, v.Client),
request.Timeout)
defer cancel()
token, err = v.oc.Exchange(ctx, code, oauth2.VerifierOption(cv))
}
if err == nil {
v.TokenSource = v.oc.TokenSource(context.Background(), token)
}
return err
}