Golang base64.NewEncoding函數代碼示例

func (this *PrePackModule) Init(global_conf *context.GlobalContext) (err error) {
	this.click_head = global_conf.Prepack.ClickHeader
	this.win_head = global_conf.Prepack.WinHeader
	this.common_head = global_conf.Prepack.CommonHeader
	utils.DebugLog.Write("Prepack.ClickHeader [%s]", this.click_head)
	utils.DebugLog.Write("Prepack.WinHeader [%s]", this.win_head)
	base64_code := [64]string{"0Ge5Q6wnuBML3Wg-8s7kAjOr2xohRHif1CczEXDKq_VaUPJdYpy9TSNvIFmbZ4tl", "1RPspa70TiZum_6tKNIFOVJ4o3gBGkdLlvhCnQHWDxEA5cq8fYzj2XU9MwrS-ybe", "2txfHr4BFaqSOTVn_CuYozeygvbcL1RNKs8MkWUPG0JpmXd5l6hDIAjw7i9E-Q3Z", "3c5gtSlVFoEXsehLaMJwI0Rv6U7xmWuzCYABP_TDp-QfdKniNrq2Ob419jHkGZy8", "456tTGIcm3EK7_RQpBA2uezWXjqnHPsi9bV-Zx8vSgkwaMlCoJ1DyfLFr0UYNhdO", "5zDkOUe_q7a2TN-Y3fvrnsCHZxhBIdcESPj8GuWXLgib4QwJo6yVtMF0Kp1mA9Rl", "6bgkOJjx8mPI9Y_hWANypSoFtnDadivQ31crfR0uC-K2qzE4UslMXGBTL5Vw7HeZ", "7zXOg9UZp0sa2vWGJP3TCBYR-6eIfHVnmdKwMrbuSlo8LFNthAkqcDy4QxE5ji1_", "8iMsWOQuApUEhoITJfjbYdLqrcF3m17XwNa_B4lVSC-Deny0KPtG6z2k5gx9vZHR", "9gdocC-fpejPiYnHF7l0XrWUAaS3OI_Nm2uDkyZbVGRJq5vt1QzhM6xTLw4BsK8E", "aJEr4IWdD3Zxw8ClmNzGPHFL9usbKTvXU-2eAkiV16ScBOy7pqgQnR0_j5MYftho", "bZqml65BeDJETLrNpMAC-tIOhVXsnf1w9_Szv7gP2xaWKR0cQ4F3Uuo8YHGdjiky", "cIJjl64KtC_doMuUeEq0fv831F2kDnNshAbzVaZTprYHB-mWXwygQ7RGxi9PL5SO", "dZgpqwv-321tRL5ITib0X8Uy64kKjoQuOsrGENxMBfY9WDea7HcmJnAC_PzSlFVh", "eUOghPNMEVoxkiG7YQL0Zmjc_IWsdl2FtRufySH4DvATBwbXCK9z5-par8J61nq3", "fP1pUQ3_moNy-7FXHAGT8uKL4wszIVMjaRdhi25E9O0kWntrBvScl6DZgqbxYJCe", "g43jISvAuK6UND0qYma2QXxRPyBib1l_zCtke5VpsEJOMf7LdZHGcFnw-hW9o8Tr", "humQGil2xCkHY391US7DvZVEbe_PR4NXWqKgrFfJApd60Bt8yno5IMawsj-OLzcT", "i2MxZ56X0LWSQGzpONHwPje_lA1nftYIvRTr-9UJs4DkydcgoVqBCu3bE7Kh8mFa", "jk9A_YBn6aqWt1yfm38SLJ7z-c42erUEHxhb5dROGgNoIusvKCDXQMTp0lZiPwVF", "kCBHjyTZmhSEwfY8JPdX9MpoKWuL61FQDtOnzab-s3INrc4qi0e7lA_gxUV5R2Gv", "lToWfMpEHAcir_JLRdBDSkaU5hPnmOCqVZ2KXNzI4uwGx01Ys379egtQ8yF-vbj6", "m36NTQ82RhD4E-tMfxjs0CPoLbirI_WBZHgnFcypezvkadXSGwO95lAKYJ7Uu1qV", "niOyHQ6oFbWzeM1qmu4tV9grTkldhGj20NELD3pRU8ZSAa7-wxKJsYcPBI5_vCXf", "odnysI_h-FGKmJQ2NvUwgVLcaOHCbSDAqlxp85Zurjzi4Mft793RYPe6TE01XkWB", "p0tGYHmhNTfdFkMQbUc1axCq4y5viXD89suS3BAIPL67VKrWolOgzwRZ_eE2jJ-n", "qrw0jSf_3pxth-LZnPoBITkGAvl7gQKdF69CVyWaD5izE4mN8ecMRHYOu2UJs1Xb", "rjUafJvNocE3D8TiQYVAHLp7WbSnzemqugBy5lIFk10_2CdM-Gh69Ksx4XRZtOwP", "sPWiyNlL3rGBI8gtfxpDbAoUe_5uhzMjZd09cTCamEwYJF6k14QvnVK7Oq-R2HXS", "tHir6_aKGnqf1RQABh3IzSwYysp4kWdUPCce2l7ZV8XJO9MmLbg50NT-vFuEoxjD", "uvfDMaj4s7hUr0GBSxWqyV6z-gnLH9QCFoJZwPK8_1lXYON2RpATId5bimEtce3k", "vy01f3dLjbn4RQuSpiEhKV_XaMB6l2cgxFI-8oUWPAY95wtmZkJNzHOCqrTe7sGD", "wDmOP9vQr_tyguqxobLHzjMC50-IAJiB4EZf1nh36sl8VWTXYGF2d7UaeSkcKpRN", "xyqhnozlE_1cV8mukNLTtHfW6r5gw2Se09A4BC3OvJdIXFpsRDiM7YbPGUajKQZ-", "y6D3Z4lYsGaxOd0nE9irmRthB7ILkPW-NbCjQpSUe12gcFK8uvofzXq5_TAHMJVw", "zH-ExpCWvMa4iPKkDdeTwq3_moAIQFXSUYGgBbL07NftO2r8nJ6lsRyu5cZhV91j", "ApKPs5S8LviIeqzyGMEmkrUhJdRgx-Q12VZFlTt9b7Y3NoBc_uOaD0CfWXHn4jw6", "BTUcJEezrnZg1YKoD3Iy_aGNOPCQtiljm90LvVWXkx48p5AHhf-dqSu67MsFwb2R", "Cfxmu205MWqpTElyPLQhODzjG36JwdsYVINZvSr471tAk_nea-R89oHbFKBicgXU", "De9UpodQBKy12HC_f6xRkYOgXv-7PNEWbuLA0qaGTScs54inrwJmZzjMF3IlVh8t", "E1RkI23NpneclxgmPyZ685Twv4aGrfCQsib-0Md9JhDO7F_VUSHqKYouAWjtBXLz", "Fu1SjpgwfAm5hU3DGdYnEsIX-kl_oaN62KWctPb098CezHZqOR4vVB7yQLixTrJM", "Gv7QT10t6edVH59gcLWOEAblzRkPyFCYNXf4I82iMmwUB_3Z-axKSspnojuJhqrD", "H-lduv6Xih9fQmF3O4JxMY7pcIjTnoatSs0CZBe15U_RyrLgPN8EwkAKGbDzW2Vq", "I9h-UfpFRlVGb_O10Zai3sq7dALjyDte2SzvMCBcYuxK5H8JwNXTPkEWr6gQno4m", "J-fYWMd6jFomtR5SP9lcqEn4aHAVx0ONILrCsyQi_pwTUhg73BvKDz2u1ZkXe8bG", "KboJvRSdBLe_r9EDz8HO-Z5GI0PW7cQuNns63gAhtYilTkqwyCF1xUVaM2m4Xfpj", "LmPDzctkaYWfSZn4yRCIBl253dw8sb9VxJEAXU6erN_Ou0GvMQg-Ko1iT7FhqpjH", "M1DFQXKTH-fJtUwBpngi04odZV3eYO9GuW86NrLh7xEslRP2z_aCkIjAcym5qSbv", "NuzOPiFag3dWUewMmyTEB5kYhcxDL2fbr_V8nRC9HGI0ZQ67KXo-lAqvJSs41jtp", "OXE5d2WJIKelZS0wj3tN6xvhP1QMrF8-nDka7HTyLi_YgVCGAzubomUf49BRcqps", "PIoQ0Vd-DgF9aYLHyGtvBcX61x8mJ_AKMU5bR3sruwTlfh42knSejNiWEqp7OZCz", "QrfzshiqxbpXZGuPV4_HL62on8YwSWITAc-eyO3djvKgNa5mE7tD10BFCMkJUl9R", "R3kYn_jgNAOJCdSwHol84aQbD7U-IhBciV20EuKM9tfrFxZ6XqzvmpLW1GPT5sey", "SLfn20Wt7oU1zMqrYkJcFZ9BmaOueV3sPTKQ5N-xbiI8DC6yp4gAvXGHlwhdRE_j", "T3JinH-K2NPsx4MuacYrXvdmWZjeOAQfp9C8tDz075qE1yVUBRb_L6whSGFoklIg", "UCvz-5K34p9OBSL8tkImg21wGYFfl6NaciZnDx7sRW0b_eyoAEQPrXqMjhHTduJV", "V4miLp8wCY0QGx7oB6_FvjWJeRs2dZK5XDNOAkhUbuMcHanT3zEIlgyr9tf-1SPq", "Wxd0EnjzS6DXcIR1qUoJMmF_fGa8uHs5h9A3VkbTiCZvNplLryKwQY4BOPg7et-2", "XYc4wekTRE8ZoxQ9dtiyO-3aAfuIjVsCFh_7Jp20rqm5SHWL1lBbnUNzDKvGPMg6", "YHS9KRLhdqbMtaeX6wG4QNp21sBFrIV_y7DlCzOx80UiumWAnT5-PkgocJEf3jZv", "Z_FmazrYTKXHW-4sSbk86D5VPyfN13gBu9deJE7q2ontjQOGhxwiCclUAMvLp0IR", "_rJb0Up6R2hNDWFAH3LswnYd7zPQo1M8KxyIjBugESqTGZtmleifcVkCX9v5-aO4", "-6mTYvy7KRxCr2elEiWbL5qMoc9G1_3untsdpjwDAzFVhZSgBN0aIOU4QkH8fJXP"}
	for i := 0; i < len(base64_code); i++ {
		this.coder[i] = base64.NewEncoding(base64_code[i])
	}
	code_char := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
	this.basecoder = base64.NewEncoding(code_char)
	this.texttpl, err = template.ParseFiles(global_conf.Template.Texttpl)
	utils.DebugLog.Write("get texttpl [%s]", global_conf.Template.Texttpl)
	if err != nil || this.texttpl == nil {
		utils.FatalLog.Write("load texttpl fail, err[%s]", err.Error())
		return
	}
	this.imgtpl, err = template.ParseFiles(global_conf.Template.Imagetpl)
	utils.DebugLog.Write("get imagetpl [%s]", global_conf.Template.Imagetpl)
	if err != nil || this.imgtpl == nil {
		utils.FatalLog.Write("load imagetpl fail, err[%s]", err.Error())
		return
	}
	this.icontexttpl, err = template.ParseFiles(global_conf.Template.Icontexttpl)
	utils.DebugLog.Write("get icontpl [%s]", global_conf.Template.Icontexttpl)
	if err != nil || this.icontexttpl == nil {
		utils.FatalLog.Write("load icontexttpl fail, err[%s]", err.Error())
		return
	}
	this.texttpl_rec, err = template.ParseFiles(global_conf.Template.Texttplrec)
	utils.DebugLog.Write("get texttpl_rec [%s]", global_conf.Template.Texttplrec)
	if err != nil || this.texttpl_rec == nil {
		utils.FatalLog.Write("load txttpl_rec fail . err[%s]", err.Error())
		return
	}
	this.imgtpl_rec, err = template.ParseFiles(global_conf.Template.Imagetplrec)
	utils.DebugLog.Write("get texttpl_rec [%s]", global_conf.Template.Imagetplrec)
	if err != nil || this.imgtpl_rec == nil {
		utils.FatalLog.Write("load imagetpl_rec fail . err[%s]", err.Error())
		return
	}
	this.icontpl_rec, err = template.ParseFiles(global_conf.Template.Icontplrec)
	utils.DebugLog.Write("get icontpl_rec [%s]", global_conf.Template.Icontplrec)
	if err != nil || this.icontpl_rec == nil {
		utils.FatalLog.Write("load icontpl_rec fail . err[%s]", err.Error())
		return
	}
	/*	this.recommendtpl, err = template.ParseFiles(global_conf.Template.Recommendtpl)
		if err != nil || this.imgtpl == nil {
			return
		}*/
	return
}

//for a websocket connection this function funcs as handshaking
//apply websocket protocal to establish a connection
func HandshakeOfWS(conn net.Conn) error {
	b := make([]byte, 1024)

	a := make([]byte, 1024)
	n, err := conn.Read(a)
	b = append(b, a[:n]...)
	if err != nil {
		if err == io.EOF {
		} else {
			return errors.New("error happen when read from connection!")
		}
	}

	re, err := regexp.Compile("Sec-WebSocket-Key: (.*)\r\n")
	if checkErr(err) {
		return errors.New("regexp error!")
	}
	result := re.FindStringSubmatch(string(b))
	if result == nil {
		return errors.New("not right format!")
	}
	key_tmp := append([]byte(result[1]), []byte(mask)...)
	key_tmp_tmp := sha1.Sum(key_tmp)
	encoder := base64.NewEncoding(base64Table)
	dst := make([]byte, 1024)
	encoder.Encode(dst, key_tmp_tmp[:])
	reply := "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: " + string(dst) + "\r\n\r\n"
	conn.Write([]byte(reply))
	return nil
}

func SendToEvernote(from, to, subject, body string) error {

	hp := strings.Split(EmailSrv, ":")
	auth := smtp.PlainAuth("", EmailUsr, EmailPwd, hp[0])

	subject = erasebractket(subject)
	tmpsubject := subject

	subidx := 0
	for len(tmpsubject) > 0 {
		_, size := utf8.DecodeRuneInString(tmpsubject)
		if subidx+size > 70 {
			break
		}
		subidx += size
		tmpsubject = tmpsubject[size:]
	}

	subject = subject[:subidx]

	subject = strings.Replace(subject, "@", "", -1)
	subject += " @股市"

	log.Println("SendToEvernote", from, subject, to)

	b64 := base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
	msg := []byte("To: " + to + "\r\nFrom: " + "xhbot" + "<" + EmailUsr + ">\r\nSubject: " + encodeRFC2047(subject) + "\r\n" + "MIME-Version: 1.0\r\n" + "Content-Type: text/html; charset=UTF-8 \r\nContent-Transfer-Encoding: base64\r\n\r\n" + b64.EncodeToString([]byte(body)))
	send_to := strings.Split(to, "|")
	err := smtp.SendMail(EmailSrv, auth, EmailUsr, send_to, msg)
	return err
}

// SignPolicy return the proper signature and other parameters needed to
// generate a valid Cloudfront Signed URL.
// For canned policies this is: Expires, Signature, Key-Pair-Id
// For custom policies this is: Policy, Signature, Key-Pair-Id
//
// More information:
//   http://goo.gl/pvA97e
// Command line equivalent:
//   cat policy | openssl sha1 -sign cloudfront-keypair.pem | openssl base64 | tr '+=/' '-_~'
func SignPolicy(privateKey PrivateKey, policy PolicySigner, keyPairID string) (string, error) {
	signature, err := policy.signWithPrivateKey(privateKey)
	if err != nil {
		return "", fmt.Errorf("Cannot sign policy: %v", err)
	}

	encoding := base64.NewEncoding(encodeCloudFront)
	paddingMap := func(r rune) rune {
		switch r {
		case '=':
			return '_'
		default:
			return r
		}
	}

	switch policy.(type) {
	case CannedPolicy:
		return fmt.Sprintf("Expires=%d&Signature=%s&Key-Pair-Id=%s",
			policy.(CannedPolicy).ExpiresAt.Unix(),
			strings.Map(paddingMap, encoding.EncodeToString(signature)),
			keyPairID,
		), nil
	case CustomPolicy:
		return fmt.Sprintf("Policy=%s&Signature=%s&Key-Pair-Id=%s",
			strings.Map(paddingMap, encoding.EncodeToString([]byte(policy.String()))),
			strings.Map(paddingMap, encoding.EncodeToString(signature)),
			keyPairID,
		), nil
	}
	return "", nil
}

func encodeBytes(b []byte) (s string) {
	// Note that this encoding is not decodable, as we are using '0' for two different bytes.
	// This is much safer for using these as parts of file names.
	enc := base64.NewEncoding("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz0")
	s = enc.EncodeToString(b)
	return
}

func main() {
	host := "192.168.0.243:25"

	from := mail.Address{"發件人", "[email protected]"}
	to := mail.Address{"收件人", "[email protected]"}
	header := make(map[string]string)
	header["From"] = from.String()
	header["To"] = to.String()
	b64 := base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
	header["Subject"] = fmt.Sprintf("=?UTF-8?B?%s?=", b64.EncodeToString([]byte("標題測試")))
	header["MIME-Version"] = "1.0"
	header["Content-Type"] = "text/html; charset=UTF-8"
	header["Content-Transfer-Encoding"] = "base64"

	body := "郵件正文"

	message := ""

	for k, v := range header {
		message += fmt.Sprintf("%s: %s\r\n", k, v)
	}
	message += "\r\n" + b64.EncodeToString([]byte(body))
	//auth := smtp.PlainAuth("", "", "", host)
	err := smtp.SendMail(host, nil, "[email protected]", []string{to.Address}, []byte(message))
	fmt.Println(err)
}

func (ca *ConnectionAcceptor) HandleConnection(conn net.Conn) {
	err := conn.(*tls.Conn).Handshake()
	if err != nil {
		log.Print("New connection failed during Handshake")
		log.Print(err)
	} else {
		state := conn.(*tls.Conn).ConnectionState()
		if len(state.PeerCertificates) == 0 {
			log.Print("New connection failed: no certificate present")
			conn.Close()
			return
		}
		hash := sha1.New()
		hash.Write(state.PeerCertificates[0].Raw)
		sha1hash := hash.Sum(nil)
		encoder := base64.NewEncoding("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/")
		hashstring := encoder.EncodeToString(sha1hash)
		if hashstring == ca.Myhash {
			log.Print("New admin connection")
			ca.out <- NewEvent("NewAdminConnection", conn)
		} else {
			ci := &UnauthConnectionInfo{conn, hashstring}
			event := NewEvent("NewUnauthenticatedConnection", ci)
			//log.Print("New unauthenticated connection")
			ca.out <- event
		}
	}
}

func Base64Encode(values []byte) string {
	if base64Encoding == nil {
		base64Encoding = base64.NewEncoding(base64CodeTbl)
	}

	return base64Encoding.EncodeToString(values)
}

func genPw(master, siteName, alphabet string) (string, error) {
	if m, _ := regexp.MatchString("[^uns]+", alphabet); m {
		return "", errors.New(fmt.Sprintf("Alphabet string %s makes no sense", alphabet))
	}
	encodeString := ""

	if strings.Contains(alphabet, "u") {
		encodeString += "QWERTYUIOPASDFGHJKLZXCVBNM"
	}
	if strings.Contains(alphabet, "n") {
		encodeString += "1234567890"
	}
	if strings.Contains(alphabet, "s") {
		encodeString += "[email protected]#$%^&*()~`{}[];:<>,.?/"
	}
	encodeString += genLowers(64 - len(encodeString))

	encoder := base64.NewEncoding(encodeString)

	c1 := sha256.Sum256([]byte(master + siteName))

	s1 := encoder.EncodeToString(c1[:12])

	return s1, nil
}

func Base64Decode(fileContent string) (string, error) {
	b64 := base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
	decodeBytes, err := b64.DecodeString(fileContent)
	if err != nil {
		return "", err
	}
	return string(decodeBytes), nil
}

func randString(l int) string {
	encoding := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
	b := make([]byte, l)
	rand.Read(b)
	enc := base64.NewEncoding(encoding)
	d := make([]byte, enc.EncodedLen(len(b)))
	enc.Encode(d, b)
	d = d[:l]
	return string(d)
}

func base64Decode(data string) ([]byte, error) {
	base := base64.NewEncoding(validEncoding)
	if len(data)%4 == 1 && data[len(data)-1] == 'A' {
		return base.DecodeString(string(data[:len(data)-1]))
	}
	if len(data)%4 != 0 {
		data = data + strings.Repeat("=", (4-(len(data)%4)))
	}
	return base.DecodeString(data)
}

func generate(secretpassword, sitename string) string {
	input := []byte(secretpassword + ":" + sitename)
	pwd := &bytes.Buffer{}
	encoder := base64.NewEncoder(base64.NewEncoding("ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz123456789?!#@&$"), pwd)
	h := sha1.New()
	h.Write(input)
	s := h.Sum(nil)
	encoder.Write(s)
	encoder.Close()
	return ensurenumberandletter(pwd.String()[:10])
}

func main() {
	s := "Love is but a song to sing Fear's the way we die You can make the mountains ring Or make the angels cry Though the bird is on the wing And you may not know why Come on people now Smile on your brother Everybody get together Try to love one another Right now"

	encodeStd := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
	s64 := base64.NewEncoding(encodeStd).EncodeToString([]byte(s))

	fmt.Println(len(s))
	fmt.Println(len(s64))
	fmt.Println(s)
	fmt.Println(s64)
}

// Configure initializes this formatter with values from a plugin config.
func (format *Base64Decode) Configure(conf core.PluginConfig) error {
	dict := conf.GetString("Dictionary", "")
	if dict == "" {
		format.dictionary = base64.StdEncoding
	} else {
		if len(dict) != 64 {
			return fmt.Errorf("Base64 dictionary must contain 64 characters.")
		}
		format.dictionary = base64.NewEncoding(dict)
	}
	return nil
}