mysql.*mysqlConn.handleAuthResult - Code Metrics - Inspection of "ISSUE-22: Add support for sqlite" - fraenky8/tables-to-go - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#23)

by Frank

created 2019-11-18 14:52 UTC

mysql.*mysqlConn.handleAuthResult F

↳ Parent: vendor/github.com/go-sql-driver/mysql/auth.go

Complexity

Conditions

Size

Total Lines	122
Code Lines	73

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	29
eloc	73
nop	2
dl	0
loc	122
rs	0
c	0
b	0
f	0

How to fix Long Method Complexity

// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
//
// Copyright 2018 The Go-MySQL-Driver Authors. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at http://mozilla.org/MPL/2.0/.

package mysql

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha1"
	"crypto/sha256"
	"crypto/x509"
	"encoding/pem"
	"sync"
)

// server pub keys registry
var (
	serverPubKeyLock     sync.RWMutex
	serverPubKeyRegistry map[string]*rsa.PublicKey
)

// RegisterServerPubKey registers a server RSA public key which can be used to
// send data in a secure manner to the server without receiving the public key
// in a potentially insecure way from the server first.
// Registered keys can afterwards be used adding serverPubKey=<name> to the DSN.
//
// Note: The provided rsa.PublicKey instance is exclusively owned by the driver
// after registering it and may not be modified.
//
//  data, err := ioutil.ReadFile("mykey.pem")
//  if err != nil {
//  	log.Fatal(err)
//  }
//
//  block, _ := pem.Decode(data)
//  if block == nil || block.Type != "PUBLIC KEY" {
//  	log.Fatal("failed to decode PEM block containing public key")
//  }
//
//  pub, err := x509.ParsePKIXPublicKey(block.Bytes)
//  if err != nil {
//  	log.Fatal(err)
//  }
//
//  if rsaPubKey, ok := pub.(*rsa.PublicKey); ok {
//  	mysql.RegisterServerPubKey("mykey", rsaPubKey)
//  } else {
//  	log.Fatal("not a RSA public key")
//  }
//
func RegisterServerPubKey(name string, pubKey *rsa.PublicKey) {
	serverPubKeyLock.Lock()
	if serverPubKeyRegistry == nil {
		serverPubKeyRegistry = make(map[string]*rsa.PublicKey)
	}

	serverPubKeyRegistry[name] = pubKey
	serverPubKeyLock.Unlock()
}

// DeregisterServerPubKey removes the public key registered with the given name.
func DeregisterServerPubKey(name string) {
	serverPubKeyLock.Lock()
	if serverPubKeyRegistry != nil {
		delete(serverPubKeyRegistry, name)
	}
	serverPubKeyLock.Unlock()
}

func getServerPubKey(name string) (pubKey *rsa.PublicKey) {
	serverPubKeyLock.RLock()
	if v, ok := serverPubKeyRegistry[name]; ok {
		pubKey = v
	}
	serverPubKeyLock.RUnlock()
	return
}

// Hash password using pre 4.1 (old password) method
// https://github.com/atcurtis/mariadb/blob/master/mysys/my_rnd.c
type myRnd struct {
	seed1, seed2 uint32
}

const myRndMaxVal = 0x3FFFFFFF

// Pseudo random number generator
func newMyRnd(seed1, seed2 uint32) *myRnd {
	return &myRnd{
		seed1: seed1 % myRndMaxVal,
		seed2: seed2 % myRndMaxVal,
	}
}

// Tested to be equivalent to MariaDB's floating point variant
// http://play.golang.org/p/QHvhd4qved
// http://play.golang.org/p/RG0q4ElWDx
func (r *myRnd) NextByte() byte {
	r.seed1 = (r.seed1*3 + r.seed2) % myRndMaxVal
	r.seed2 = (r.seed1 + r.seed2 + 33) % myRndMaxVal

	return byte(uint64(r.seed1) * 31 / myRndMaxVal)
}

// Generate binary hash from byte string using insecure pre 4.1 method
func pwHash(password []byte) (result [2]uint32) {
	var add uint32 = 7
	var tmp uint32

	result[0] = 1345345333
	result[1] = 0x12345671

	for _, c := range password {
		// skip spaces and tabs in password
		if c == ' ' || c == '\t' {
			continue
		}

		tmp = uint32(c)
		result[0] ^= (((result[0] & 63) + add) * tmp) + (result[0] << 8)
		result[1] += (result[1] << 8) ^ result[0]
		add += tmp
	}

	// Remove sign bit (1<<31)-1)
	result[0] &= 0x7FFFFFFF
	result[1] &= 0x7FFFFFFF

	return
}

// Hash password using insecure pre 4.1 method
func scrambleOldPassword(scramble []byte, password string) []byte {
	if len(password) == 0 {
		return nil
	}

	scramble = scramble[:8]

	hashPw := pwHash([]byte(password))
	hashSc := pwHash(scramble)

	r := newMyRnd(hashPw[0]^hashSc[0], hashPw[1]^hashSc[1])

	var out [8]byte
	for i := range out {
		out[i] = r.NextByte() + 64
	}

	mask := r.NextByte()
	for i := range out {
		out[i] ^= mask
	}

	return out[:]
}

// Hash password using 4.1+ method (SHA1)
func scramblePassword(scramble []byte, password string) []byte {
	if len(password) == 0 {
		return nil
	}

	// stage1Hash = SHA1(password)
	crypt := sha1.New()
	crypt.Write([]byte(password))
	stage1 := crypt.Sum(nil)

	// scrambleHash = SHA1(scramble + SHA1(stage1Hash))
	// inner Hash
	crypt.Reset()
	crypt.Write(stage1)
	hash := crypt.Sum(nil)

	// outer Hash
	crypt.Reset()
	crypt.Write(scramble)
	crypt.Write(hash)
	scramble = crypt.Sum(nil)

	// token = scrambleHash XOR stage1Hash
	for i := range scramble {
		scramble[i] ^= stage1[i]
	}
	return scramble
}

// Hash password using MySQL 8+ method (SHA256)
func scrambleSHA256Password(scramble []byte, password string) []byte {
	if len(password) == 0 {
		return nil
	}

	// XOR(SHA256(password), SHA256(SHA256(SHA256(password)), scramble))

	crypt := sha256.New()
	crypt.Write([]byte(password))
	message1 := crypt.Sum(nil)

	crypt.Reset()
	crypt.Write(message1)
	message1Hash := crypt.Sum(nil)

	crypt.Reset()
	crypt.Write(message1Hash)
	crypt.Write(scramble)
	message2 := crypt.Sum(nil)

	for i := range message1 {
		message1[i] ^= message2[i]
	}

	return message1
}

func encryptPassword(password string, seed []byte, pub *rsa.PublicKey) ([]byte, error) {
	plain := make([]byte, len(password)+1)
	copy(plain, password)
	for i := range plain {
		j := i % len(seed)
		plain[i] ^= seed[j]
	}
	sha1 := sha1.New()
	return rsa.EncryptOAEP(sha1, rand.Reader, pub, plain, nil)
}

func (mc *mysqlConn) sendEncryptedPassword(seed []byte, pub *rsa.PublicKey) error {
	enc, err := encryptPassword(mc.cfg.Passwd, seed, pub)
	if err != nil {
		return err
	}
	return mc.writeAuthSwitchPacket(enc)
}

func (mc *mysqlConn) auth(authData []byte, plugin string) ([]byte, error) {
	switch plugin {
	case "caching_sha2_password":
		authResp := scrambleSHA256Password(authData, mc.cfg.Passwd)
		return authResp, nil

	case "mysql_old_password":
		if !mc.cfg.AllowOldPasswords {
			return nil, ErrOldPassword
		}
		// Note: there are edge cases where this should work but doesn't;
		// this is currently "wontfix":
		// https://github.com/go-sql-driver/mysql/issues/184
		authResp := append(scrambleOldPassword(authData[:8], mc.cfg.Passwd), 0)
		return authResp, nil

	case "mysql_clear_password":
		if !mc.cfg.AllowCleartextPasswords {
			return nil, ErrCleartextPassword
		}
		// http://dev.mysql.com/doc/refman/5.7/en/cleartext-authentication-plugin.html
		// http://dev.mysql.com/doc/refman/5.7/en/pam-authentication-plugin.html
		return append([]byte(mc.cfg.Passwd), 0), nil

	case "mysql_native_password":
		if !mc.cfg.AllowNativePasswords {
			return nil, ErrNativePassword
		}
		// https://dev.mysql.com/doc/internals/en/secure-password-authentication.html
		// Native password authentication only need and will need 20-byte challenge.
		authResp := scramblePassword(authData[:20], mc.cfg.Passwd)
		return authResp, nil

	case "sha256_password":
		if len(mc.cfg.Passwd) == 0 {
			return []byte{0}, nil
		}
		if mc.cfg.tls != nil || mc.cfg.Net == "unix" {
			// write cleartext auth packet
			return append([]byte(mc.cfg.Passwd), 0), nil
		}

		pubKey := mc.cfg.pubKey
		if pubKey == nil {
			// request public key from server
			return []byte{1}, nil
		}

		// encrypted password
		enc, err := encryptPassword(mc.cfg.Passwd, authData, pubKey)
		return enc, err

	default:
		errLog.Print("unknown auth plugin:", plugin)
		return nil, ErrUnknownPlugin
	}
}

func (mc *mysqlConn) handleAuthResult(oldAuthData []byte, plugin string) error {
	// Read Result Packet
	authData, newPlugin, err := mc.readAuthResult()
	if err != nil {
		return err
	}

	// handle auth plugin switch, if requested
	if newPlugin != "" {
		// If CLIENT_PLUGIN_AUTH capability is not supported, no new cipher is
		// sent and we have to keep using the cipher sent in the init packet.
		if authData == nil {
			authData = oldAuthData
		} else {
			// copy data from read buffer to owned slice
			copy(oldAuthData, authData)
		}

		plugin = newPlugin

		authResp, err := mc.auth(authData, plugin)
		if err != nil {
			return err
		}
		if err = mc.writeAuthSwitchPacket(authResp); err != nil {
			return err
		}

		// Read Result Packet
		authData, newPlugin, err = mc.readAuthResult()
		if err != nil {
			return err
		}

		// Do not allow to change the auth plugin more than once
		if newPlugin != "" {
			return ErrMalformPkt
		}
	}

	switch plugin {

	// https://insidemysql.com/preparing-your-community-connector-for-mysql-8-part-2-sha256/
	case "caching_sha2_password":
		switch len(authData) {
		case 0:
			return nil // auth successful
		case 1:
			switch authData[0] {
			case cachingSha2PasswordFastAuthSuccess:
				if err = mc.readResultOK(); err == nil {
					return nil // auth successful
				}

			case cachingSha2PasswordPerformFullAuthentication:
				if mc.cfg.tls != nil || mc.cfg.Net == "unix" {
					// write cleartext auth packet
					err = mc.writeAuthSwitchPacket(append([]byte(mc.cfg.Passwd), 0))
					if err != nil {
						return err
					}
				} else {
					pubKey := mc.cfg.pubKey
					if pubKey == nil {
						// request public key from server
						data := mc.buf.takeSmallBuffer(4 + 1)
						data[4] = cachingSha2PasswordRequestPublicKey
						mc.writePacket(data)

						// parse public key
						data, err := mc.readPacket()
						if err != nil {
							return err
						}

						block, _ := pem.Decode(data[1:])
						pkix, err := x509.ParsePKIXPublicKey(block.Bytes)
						if err != nil {
							return err
						}
						pubKey = pkix.(*rsa.PublicKey)
					}

					// send encrypted password
					err = mc.sendEncryptedPassword(oldAuthData, pubKey)
					if err != nil {
						return err
					}
				}
				return mc.readResultOK()

			default:
				return ErrMalformPkt
			}
		default:
			return ErrMalformPkt
		}

	case "sha256_password":
		switch len(authData) {
		case 0:
			return nil // auth successful
		default:
			block, _ := pem.Decode(authData)
			pub, err := x509.ParsePKIXPublicKey(block.Bytes)
			if err != nil {
				return err
			}

			// send encrypted password
			err = mc.sendEncryptedPassword(oldAuthData, pub.(*rsa.PublicKey))
			if err != nil {
				return err
			}
			return mc.readResultOK()
		}

	default:
		return nil // auth successful
	}

	return err
}


1			// Go MySQL Driver - A MySQL-Driver for Go's database/sql package
2			//
3			// Copyright 2018 The Go-MySQL-Driver Authors. All rights reserved.
4			//
5			// This Source Code Form is subject to the terms of the Mozilla Public
6			// License, v. 2.0. If a copy of the MPL was not distributed with this file,
7			// You can obtain one at http://mozilla.org/MPL/2.0/.
8
9			package mysql
10
11			import (
12			"crypto/rand"
13			"crypto/rsa"
14			"crypto/sha1"
15			"crypto/sha256"
16			"crypto/x509"
17			"encoding/pem"
18			"sync"
19			)
20
21			// server pub keys registry
22			var (
23			serverPubKeyLock sync.RWMutex
24			serverPubKeyRegistry map[string]*rsa.PublicKey
25			)
26
27			// RegisterServerPubKey registers a server RSA public key which can be used to
28			// send data in a secure manner to the server without receiving the public key
29			// in a potentially insecure way from the server first.
30			// Registered keys can afterwards be used adding serverPubKey=<name> to the DSN.
31			//
32			// Note: The provided rsa.PublicKey instance is exclusively owned by the driver
33			// after registering it and may not be modified.
34			//
35			// data, err := ioutil.ReadFile("mykey.pem")
36			// if err != nil {
37			// log.Fatal(err)
38			// }
39			//
40			// block, _ := pem.Decode(data)
41			// if block == nil \|\| block.Type != "PUBLIC KEY" {
42			// log.Fatal("failed to decode PEM block containing public key")
43			// }
44			//
45			// pub, err := x509.ParsePKIXPublicKey(block.Bytes)
46			// if err != nil {
47			// log.Fatal(err)
48			// }
49			//
50			// if rsaPubKey, ok := pub.(*rsa.PublicKey); ok {
51			// mysql.RegisterServerPubKey("mykey", rsaPubKey)
52			// } else {
53			// log.Fatal("not a RSA public key")
54			// }
55			//
56			func RegisterServerPubKey(name string, pubKey *rsa.PublicKey) {
57			serverPubKeyLock.Lock()
58			if serverPubKeyRegistry == nil {
59			serverPubKeyRegistry = make(map[string]*rsa.PublicKey)
60			}
61
62			serverPubKeyRegistry[name] = pubKey
63			serverPubKeyLock.Unlock()
64			}
65
66			// DeregisterServerPubKey removes the public key registered with the given name.
67			func DeregisterServerPubKey(name string) {
68			serverPubKeyLock.Lock()
69			if serverPubKeyRegistry != nil {
70			delete(serverPubKeyRegistry, name)
71			}
72			serverPubKeyLock.Unlock()
73			}
74
75			func getServerPubKey(name string) (pubKey *rsa.PublicKey) {
76			serverPubKeyLock.RLock()
77			if v, ok := serverPubKeyRegistry[name]; ok {
78			pubKey = v
79			}
80			serverPubKeyLock.RUnlock()
81			return
82			}
83
84			// Hash password using pre 4.1 (old password) method
85			// https://github.com/atcurtis/mariadb/blob/master/mysys/my_rnd.c
86			type myRnd struct {
87			seed1, seed2 uint32
88			}
89
90			const myRndMaxVal = 0x3FFFFFFF
91
92			// Pseudo random number generator
93			func newMyRnd(seed1, seed2 uint32) *myRnd {
94			return &myRnd{
95			seed1: seed1 % myRndMaxVal,
96			seed2: seed2 % myRndMaxVal,
97			}
98			}
99
100			// Tested to be equivalent to MariaDB's floating point variant
101			// http://play.golang.org/p/QHvhd4qved
102			// http://play.golang.org/p/RG0q4ElWDx
103			func (r *myRnd) NextByte() byte {
104			r.seed1 = (r.seed1*3 + r.seed2) % myRndMaxVal
105			r.seed2 = (r.seed1 + r.seed2 + 33) % myRndMaxVal
106
107			return byte(uint64(r.seed1) * 31 / myRndMaxVal)
108			}
109
110			// Generate binary hash from byte string using insecure pre 4.1 method
111			func pwHash(password []byte) (result [2]uint32) {
112			var add uint32 = 7
113			var tmp uint32
114
115			result[0] = 1345345333
116			result[1] = 0x12345671
117
118			for _, c := range password {
119			// skip spaces and tabs in password
120			if c == ' ' \|\| c == '\t' {
121			continue
122			}
123
124			tmp = uint32(c)
125			result[0] ^= (((result[0] & 63) + add) * tmp) + (result[0] << 8)
126			result[1] += (result[1] << 8) ^ result[0]
127			add += tmp
128			}
129
130			// Remove sign bit (1<<31)-1)
131			result[0] &= 0x7FFFFFFF
132			result[1] &= 0x7FFFFFFF
133
134			return
135			}
136
137			// Hash password using insecure pre 4.1 method
138			func scrambleOldPassword(scramble []byte, password string) []byte {
139			if len(password) == 0 {
140			return nil
141			}
142
143			scramble = scramble[:8]
144
145			hashPw := pwHash([]byte(password))
146			hashSc := pwHash(scramble)
147
148			r := newMyRnd(hashPw[0]^hashSc[0], hashPw[1]^hashSc[1])
149
150			var out [8]byte
151			for i := range out {
152			out[i] = r.NextByte() + 64
153			}
154
155			mask := r.NextByte()
156			for i := range out {
157			out[i] ^= mask
158			}
159
160			return out[:]
161			}
162
163			// Hash password using 4.1+ method (SHA1)
164			func scramblePassword(scramble []byte, password string) []byte {
165			if len(password) == 0 {
166			return nil
167			}
168
169			// stage1Hash = SHA1(password)
170			crypt := sha1.New()
171			crypt.Write([]byte(password))
172			stage1 := crypt.Sum(nil)
173
174			// scrambleHash = SHA1(scramble + SHA1(stage1Hash))
175			// inner Hash
176			crypt.Reset()
177			crypt.Write(stage1)
178			hash := crypt.Sum(nil)
179
180			// outer Hash
181			crypt.Reset()
182			crypt.Write(scramble)
183			crypt.Write(hash)
184			scramble = crypt.Sum(nil)
185
186			// token = scrambleHash XOR stage1Hash
187			for i := range scramble {
188			scramble[i] ^= stage1[i]
189			}
190			return scramble
191			}
192
193			// Hash password using MySQL 8+ method (SHA256)
194			func scrambleSHA256Password(scramble []byte, password string) []byte {
195			if len(password) == 0 {
196			return nil
197			}
198
199			// XOR(SHA256(password), SHA256(SHA256(SHA256(password)), scramble))
200
201			crypt := sha256.New()
202			crypt.Write([]byte(password))
203			message1 := crypt.Sum(nil)
204
205			crypt.Reset()
206			crypt.Write(message1)
207			message1Hash := crypt.Sum(nil)
208
209			crypt.Reset()
210			crypt.Write(message1Hash)
211			crypt.Write(scramble)
212			message2 := crypt.Sum(nil)
213
214			for i := range message1 {
215			message1[i] ^= message2[i]
216			}
217
218			return message1
219			}
220
221			func encryptPassword(password string, seed []byte, pub *rsa.PublicKey) ([]byte, error) {
222			plain := make([]byte, len(password)+1)
223			copy(plain, password)
224			for i := range plain {
225			j := i % len(seed)
226			plain[i] ^= seed[j]
227			}
228			sha1 := sha1.New()
229			return rsa.EncryptOAEP(sha1, rand.Reader, pub, plain, nil)
230			}
231
232			func (mc mysqlConn) sendEncryptedPassword(seed []byte, pub rsa.PublicKey) error {
233			enc, err := encryptPassword(mc.cfg.Passwd, seed, pub)
234			if err != nil {
235			return err
236			}
237			return mc.writeAuthSwitchPacket(enc)
238			}
239
240			func (mc *mysqlConn) auth(authData []byte, plugin string) ([]byte, error) {
241			switch plugin {
242			case "caching_sha2_password":
243			authResp := scrambleSHA256Password(authData, mc.cfg.Passwd)
244			return authResp, nil
245
246			case "mysql_old_password":
247			if !mc.cfg.AllowOldPasswords {
248			return nil, ErrOldPassword
249			}
250			// Note: there are edge cases where this should work but doesn't;
251			// this is currently "wontfix":
252			// https://github.com/go-sql-driver/mysql/issues/184
253			authResp := append(scrambleOldPassword(authData[:8], mc.cfg.Passwd), 0)
254			return authResp, nil
255
256			case "mysql_clear_password":
257			if !mc.cfg.AllowCleartextPasswords {
258			return nil, ErrCleartextPassword
259			}
260			// http://dev.mysql.com/doc/refman/5.7/en/cleartext-authentication-plugin.html
261			// http://dev.mysql.com/doc/refman/5.7/en/pam-authentication-plugin.html
262			return append([]byte(mc.cfg.Passwd), 0), nil
263
264			case "mysql_native_password":
265			if !mc.cfg.AllowNativePasswords {
266			return nil, ErrNativePassword
267			}
268			// https://dev.mysql.com/doc/internals/en/secure-password-authentication.html
269			// Native password authentication only need and will need 20-byte challenge.
270			authResp := scramblePassword(authData[:20], mc.cfg.Passwd)
271			return authResp, nil
272
273			case "sha256_password":
274			if len(mc.cfg.Passwd) == 0 {
275			return []byte{0}, nil
276			}
277			if mc.cfg.tls != nil \|\| mc.cfg.Net == "unix" {
278			// write cleartext auth packet
279			return append([]byte(mc.cfg.Passwd), 0), nil
280			}
281
282			pubKey := mc.cfg.pubKey
283			if pubKey == nil {
284			// request public key from server
285			return []byte{1}, nil
286			}
287
288			// encrypted password
289			enc, err := encryptPassword(mc.cfg.Passwd, authData, pubKey)
290			return enc, err
291
292			default:
293			errLog.Print("unknown auth plugin:", plugin)
294			return nil, ErrUnknownPlugin
295			}
296			}
297
298			func (mc *mysqlConn) handleAuthResult(oldAuthData []byte, plugin string) error {
299			// Read Result Packet
300			authData, newPlugin, err := mc.readAuthResult()
301			if err != nil {
302			return err
303			}
304
305			// handle auth plugin switch, if requested
306			if newPlugin != "" {
307			// If CLIENT_PLUGIN_AUTH capability is not supported, no new cipher is
308			// sent and we have to keep using the cipher sent in the init packet.
309			if authData == nil {
310			authData = oldAuthData
311			} else {
312			// copy data from read buffer to owned slice
313			copy(oldAuthData, authData)
314			}
315
316			plugin = newPlugin
317
318			authResp, err := mc.auth(authData, plugin)
319			if err != nil {
320			return err
321			}
322			if err = mc.writeAuthSwitchPacket(authResp); err != nil {
323			return err
324			}
325
326			// Read Result Packet
327			authData, newPlugin, err = mc.readAuthResult()
328			if err != nil {
329			return err
330			}
331
332			// Do not allow to change the auth plugin more than once
333			if newPlugin != "" {
334			return ErrMalformPkt
335			}
336			}
337
338			switch plugin {
339
340			// https://insidemysql.com/preparing-your-community-connector-for-mysql-8-part-2-sha256/
341			case "caching_sha2_password":
342			switch len(authData) {
343			case 0:
344			return nil // auth successful
345			case 1:
346			switch authData[0] {
347			case cachingSha2PasswordFastAuthSuccess:
348			if err = mc.readResultOK(); err == nil {
349			return nil // auth successful
350			}
351
352			case cachingSha2PasswordPerformFullAuthentication:
353			if mc.cfg.tls != nil \|\| mc.cfg.Net == "unix" {
354			// write cleartext auth packet
355			err = mc.writeAuthSwitchPacket(append([]byte(mc.cfg.Passwd), 0))
356			if err != nil {
357			return err
358			}
359			} else {
360			pubKey := mc.cfg.pubKey
361			if pubKey == nil {
362			// request public key from server
363			data := mc.buf.takeSmallBuffer(4 + 1)
364			data[4] = cachingSha2PasswordRequestPublicKey
365			mc.writePacket(data)
366
367			// parse public key
368			data, err := mc.readPacket()
369			if err != nil {
370			return err
371			}
372
373			block, _ := pem.Decode(data[1:])
374			pkix, err := x509.ParsePKIXPublicKey(block.Bytes)
375			if err != nil {
376			return err
377			}
378			pubKey = pkix.(*rsa.PublicKey)
379			}
380
381			// send encrypted password
382			err = mc.sendEncryptedPassword(oldAuthData, pubKey)
383			if err != nil {
384			return err
385			}
386			}
387			return mc.readResultOK()
388
389			default:
390			return ErrMalformPkt
391			}
392			default:
393			return ErrMalformPkt
394			}
395
396			case "sha256_password":
397			switch len(authData) {
398			case 0:
399			return nil // auth successful
400			default:
401			block, _ := pem.Decode(authData)
402			pub, err := x509.ParsePKIXPublicKey(block.Bytes)
403			if err != nil {
404			return err
405			}
406
407			// send encrypted password
408			err = mc.sendEncryptedPassword(oldAuthData, pub.(*rsa.PublicKey))
409			if err != nil {
410			return err
411			}
412			return mc.readResultOK()
413			}
414
415			default:
416			return nil // auth successful
417			}
418
419			return err
420			}
421

fraenky8 / tables-to-go

Pull Request — master (#23)

mysql.*mysqlConn.handleAuthResult F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like