Debian Codegraph @

spnego/krb5Token.go

raw
1 package spnego
2
3 import (
4 "context"
5 "encoding/binary"
6 "encoding/hex"
7 "errors"
8 "fmt"
9
10 "github.com/jcmturner/gofork/encoding/asn1"
11 "gopkg.in/jcmturner/gokrb5.v7/asn1tools"
12 "gopkg.in/jcmturner/gokrb5.v7/client"
13 "gopkg.in/jcmturner/gokrb5.v7/credentials"
14 "gopkg.in/jcmturner/gokrb5.v7/gssapi"
15 "gopkg.in/jcmturner/gokrb5.v7/iana/chksumtype"
16 "gopkg.in/jcmturner/gokrb5.v7/iana/msgtype"
17 "gopkg.in/jcmturner/gokrb5.v7/krberror"
18 "gopkg.in/jcmturner/gokrb5.v7/messages"
19 "gopkg.in/jcmturner/gokrb5.v7/service"
20 "gopkg.in/jcmturner/gokrb5.v7/types"
21 )
22
23 // GSSAPI KRB5 MechToken IDs.
24 const (
25 TOK_ID_KRB_AP_REQ = "0100"
26 TOK_ID_KRB_AP_REP = "0200"
27 TOK_ID_KRB_ERROR = "0300"
28 )
29
30 // KRB5Token context token implementation for GSSAPI.
31 type KRB5Token struct {
32 OID asn1.ObjectIdentifier
33 tokID []byte
34 APReq messages.APReq
35 APRep messages.APRep
36 KRBError messages.KRBError
37 settings *service.Settings
38 context context.Context
39 }
40
41 // Marshal a KRB5Token into a slice of bytes.
42 func (m *KRB5Token) Marshal() ([]byte, error) {
43 // Create the header
44 b, _ := asn1.Marshal(m.OID)
45 b = append(b, m.tokID...)
46 var tb []byte
47 var err error
48 switch hex.EncodeToString(m.tokID) {
49 case TOK_ID_KRB_AP_REQ:
50 tb, err = m.APReq.Marshal()
51 if err != nil {
52 return []byte{}, fmt.Errorf("error marshalling AP_REQ for MechToken: %v", err)
53 }
54 case TOK_ID_KRB_AP_REP:
55 return []byte{}, errors.New("marshal of AP_REP GSSAPI MechToken not supported by gokrb5")
56 case TOK_ID_KRB_ERROR:
57 return []byte{}, errors.New("marshal of KRB_ERROR GSSAPI MechToken not supported by gokrb5")
58 }
59 if err != nil {
60 return []byte{}, fmt.Errorf("error mashalling kerberos message within mech token: %v", err)
61 }
62 b = append(b, tb...)
63 return asn1tools.AddASNAppTag(b, 0), nil
64 }
65
66 // Unmarshal a KRB5Token.
67 func (m *KRB5Token) Unmarshal(b []byte) error {
68 var oid asn1.ObjectIdentifier
69 r, err := asn1.UnmarshalWithParams(b, &oid, fmt.Sprintf("application,explicit,tag:%v", 0))
70 if err != nil {
71 return fmt.Errorf("error unmarshalling KRB5Token OID: %v", err)
72 }
73 if !oid.Equal(gssapi.OID(gssapi.OIDKRB5)) {
74 return fmt.Errorf("error unmarshalling KRB5Token, OID is %s not %s", oid.String(), gssapi.OID(gssapi.OIDKRB5).String())
75 }
76 m.OID = oid
77 if len(r) < 2 {
78 return fmt.Errorf("krb5token too short")
79 }
80 m.tokID = r[0:2]
81 switch hex.EncodeToString(m.tokID) {
82 case TOK_ID_KRB_AP_REQ:
83 var a messages.APReq
84 err = a.Unmarshal(r[2:])
85 if err != nil {
86 return fmt.Errorf("error unmarshalling KRB5Token AP_REQ: %v", err)
87 }
88 m.APReq = a
89 case TOK_ID_KRB_AP_REP:
90 var a messages.APRep
91 err = a.Unmarshal(r[2:])
92 if err != nil {
93 return fmt.Errorf("error unmarshalling KRB5Token AP_REP: %v", err)
94 }
95 m.APRep = a
96 case TOK_ID_KRB_ERROR:
97 var a messages.KRBError
98 err = a.Unmarshal(r[2:])
99 if err != nil {
100 return fmt.Errorf("error unmarshalling KRB5Token KRBError: %v", err)
101 }
102 m.KRBError = a
103 }
104 return nil
105 }
106
107 // Verify a KRB5Token.
108 func (m *KRB5Token) Verify() (bool, gssapi.Status) {
109 switch hex.EncodeToString(m.tokID) {
110 case TOK_ID_KRB_AP_REQ:
111 ok, creds, err := service.VerifyAPREQ(m.APReq, m.settings)
112 if err != nil {
113 return false, gssapi.Status{Code: gssapi.StatusDefectiveToken, Message: err.Error()}
114 }
115 if !ok {
116 return false, gssapi.Status{Code: gssapi.StatusDefectiveCredential, Message: "KRB5_AP_REQ token not valid"}
117 }
118 m.context = context.Background()
119 m.context = context.WithValue(m.context, CTXKeyCredentials, creds)
120 m.context = context.WithValue(m.context, CTXKeyAuthenticated, ok)
121 return true, gssapi.Status{Code: gssapi.StatusComplete}
122 case TOK_ID_KRB_AP_REP:
123 // Client side
124 // TODO how to verify the AP_REP - not yet implemented
125 return false, gssapi.Status{Code: gssapi.StatusFailure, Message: "verifying an AP_REP is not currently supported by gokrb5"}
126 case TOK_ID_KRB_ERROR:
127 if m.KRBError.MsgType != msgtype.KRB_ERROR {
128 return false, gssapi.Status{Code: gssapi.StatusDefectiveToken, Message: "KRB5_Error token not valid"}
129 }
130 return true, gssapi.Status{Code: gssapi.StatusUnavailable}
131 }
132 return false, gssapi.Status{Code: gssapi.StatusDefectiveToken, Message: "unknown TOK_ID in KRB5 token"}
133 }
134
135 // IsAPReq tests if the MechToken contains an AP_REQ.
136 func (m *KRB5Token) IsAPReq() bool {
137 if hex.EncodeToString(m.tokID) == TOK_ID_KRB_AP_REQ {
138 return true
139 }
140 return false
141 }
142
143 // IsAPRep tests if the MechToken contains an AP_REP.
144 func (m *KRB5Token) IsAPRep() bool {
145 if hex.EncodeToString(m.tokID) == TOK_ID_KRB_AP_REP {
146 return true
147 }
148 return false
149 }
150
151 // IsKRBError tests if the MechToken contains an KRB_ERROR.
152 func (m *KRB5Token) IsKRBError() bool {
153 if hex.EncodeToString(m.tokID) == TOK_ID_KRB_ERROR {
154 return true
155 }
156 return false
157 }
158
159 // Context returns the KRB5 token's context which will contain any verify user identity information.
160 func (m *KRB5Token) Context() context.Context {
161 return m.context
162 }
163
164 // NewKRB5TokenAPREQ creates a new KRB5 token with AP_REQ
165 func NewKRB5TokenAPREQ(cl *client.Client, tkt messages.Ticket, sessionKey types.EncryptionKey, GSSAPIFlags []int, APOptions []int) (KRB5Token, error) {
166 // TODO consider providing the SPN rather than the specific tkt and key and get these from the krb client.
167 var m KRB5Token
168 m.OID = gssapi.OID(gssapi.OIDKRB5)
169 tb, _ := hex.DecodeString(TOK_ID_KRB_AP_REQ)
170 m.tokID = tb
171
172 auth, err := krb5TokenAuthenticator(cl.Credentials, GSSAPIFlags)
173 if err != nil {
174 return m, err
175 }
176 APReq, err := messages.NewAPReq(
177 tkt,
178 sessionKey,
179 auth,
180 )
181 if err != nil {
182 return m, err
183 }
184 for _, o := range APOptions {
185 types.SetFlag(&APReq.APOptions, o)
186 }
187 m.APReq = APReq
188 return m, nil
189 }
190
191 // krb5TokenAuthenticator creates a new kerberos authenticator for kerberos MechToken
192 func krb5TokenAuthenticator(creds *credentials.Credentials, flags []int) (types.Authenticator, error) {
193 //RFC 4121 Section 4.1.1
194 auth, err := types.NewAuthenticator(creds.Domain(), creds.CName())
195 if err != nil {
196 return auth, krberror.Errorf(err, krberror.KRBMsgError, "error generating new authenticator")
197 }
198 auth.Cksum = types.Checksum{
199 CksumType: chksumtype.GSSAPI,
200 Checksum: newAuthenticatorChksum(flags),
201 }
202 return auth, nil
203 }
204
205 // Create new authenticator checksum for kerberos MechToken
206 func newAuthenticatorChksum(flags []int) []byte {
207 a := make([]byte, 24)
208 binary.LittleEndian.PutUint32(a[:4], 16)
209 for _, i := range flags {
210 if i == gssapi.ContextFlagDeleg {
211 x := make([]byte, 28-len(a))
212 a = append(a, x...)
213 }
214 f := binary.LittleEndian.Uint32(a[20:24])
215 f |= uint32(i)
216 binary.LittleEndian.PutUint32(a[20:24], f)
217 }
218 return a
219 }