func main() {
var TestString string
for {
fmt.Scanln(&TestString)
Result1 := md5.Sum([]byte(TestString))
fmt.Printf("md5 1: %x\n", Result1)
tmpMd5 := fmt.Sprintf("%x", Result1)
Result := md5.Sum([]byte(tmpMd5))
tmpMd52 := fmt.Sprintf("%x", Result)
fmt.Printf("md5 2: %s\n", tmpMd52)
// Second md5 value
//Md5Inst1 := md5.New()
//Md5Inst1.Write([]byte(tmpMd5))
//Result = Md5Inst1.Sum([]byte(""))
//fmt.Printf("md5 2: %x\n", Result)
// Third: sha1 value
//Sha1Inst := sha1.New()
//Sha1Inst.Write([]byte(tmpMd52))
//Result2 := Sha1Inst.Sum([]byte(""))
Result2 := sha1.Sum([]byte(tmpMd52))
fmt.Printf("sha1 after md5 2: %x\n", Result2)
}
}
func (fix Fix) Apply() error {
path := filepath.Join(mpqpath, fix.path)
buf, err := ioutil.ReadFile(path)
if err != nil {
return err
}
oldsum := md5.Sum(buf)
if oldsum == fix.newsum {
return fmt.Errorf("%q already patched.", fix.path)
}
if oldsum != fix.oldsum {
return fmt.Errorf("MD5 checksum mismatch for unpatched version of %q.", fix.path)
}
err = ioutil.WriteFile(path+".orig", buf, 0644)
if err != nil {
return fmt.Errorf("failed to create backup for %q; %v", fix.path, err)
}
for pos, val := range fix.data {
buf[pos] = val
}
newsum := md5.Sum(buf)
if newsum != fix.newsum {
return fmt.Errorf("MD5 checksum mismatch for patched version of %q.", fix.path)
}
return ioutil.WriteFile(path, buf, 0644)
}
func handleResponse(conn net.Conn, request *protocol.VMessRequest, output chan<- *alloc.Buffer, finish *sync.Mutex, isUDP bool) {
defer finish.Unlock()
defer close(output)
responseKey := md5.Sum(request.RequestKey[:])
responseIV := md5.Sum(request.RequestIV[:])
decryptResponseReader, err := v2io.NewAesDecryptReader(responseKey[:], responseIV[:], conn)
if err != nil {
log.Error("VMessOut: Failed to create decrypt reader: %v", err)
return
}
buffer, err := v2net.ReadFrom(decryptResponseReader, nil)
if err != nil {
log.Error("VMessOut: Failed to read VMess response (%d bytes): %v", buffer.Len(), err)
return
}
if buffer.Len() < 4 || !bytes.Equal(buffer.Value[:4], request.ResponseHeader[:]) {
log.Warning("VMessOut: unexepcted response header. The connection is probably hijacked.")
return
}
log.Info("VMessOut received %d bytes from %s", buffer.Len()-4, conn.RemoteAddr().String())
buffer.SliceFrom(4)
output <- buffer
if !isUDP {
v2net.ReaderToChan(output, decryptResponseReader)
}
return
}
// Calculate geoipupdate URL
// The auto update URL for paid products has a fun scheme.
// Use this function to calculate that URL from various information
func GeoIPUpdateURL(hostName string, userID string, licenseKey string, productID string) (url string, err error) {
// Get the file name from the product
url = fmt.Sprintf("%s://%s/app/update_getfilename?product_id=%s", "https", hostName, productID)
resp, err := http.Get(url)
if err != nil {
return "", err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return "", err
}
hexDigest := fmt.Sprintf("%x", md5.Sum(body))
// Get our client IP address
url = fmt.Sprintf("%s://%s/app/update_getipaddr", "https", hostName)
resp, err = http.Get(url)
if err != nil {
return "", err
}
defer resp.Body.Close()
body, err = ioutil.ReadAll(resp.Body)
if err != nil {
return "", err
}
challenge := []byte(fmt.Sprintf("%s%s", licenseKey, body))
hexDigest2 := fmt.Sprintf("%x", md5.Sum(challenge))
// Create the URL
return fmt.Sprintf("%s://%s/app/update_secure?db_md5=%s&challenge_md5=%s&user_id=%s&edition_id=%s", "https", hostName, hexDigest, hexDigest2, userID, productID), nil
}
// 注销一个管道
func (s *Socket) UnregisterChannel(name string) {
if s.isClose {
return
}
s.netchans[md5.Sum([]byte(name))].Close(ChanClosedErr)
delete(s.netchans, md5.Sum([]byte(name)))
}
func (handler *VMessOutboundHandler) startCommunicate(request *vmessio.VMessRequest, dest v2net.Address, ray core.OutboundRay) error {
conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{dest.IP, int(dest.Port), ""})
log.Debug("VMessOutbound dialing tcp: %s", dest.String())
if err != nil {
log.Error("Failed to open tcp (%s): %v", dest.String(), err)
return err
}
defer conn.Close()
input := ray.OutboundInput()
output := ray.OutboundOutput()
requestWriter := vmessio.NewVMessRequestWriter()
err = requestWriter.Write(conn, request)
if err != nil {
log.Error("Failed to write VMess request: %v", err)
close(output)
return err
}
requestKey := request.RequestKey[:]
requestIV := request.RequestIV[:]
responseKey := md5.Sum(requestKey)
responseIV := md5.Sum(requestIV)
response := vmessio.VMessResponse{}
nBytes, err := conn.Read(response[:])
if err != nil {
close(output)
log.Error("Failed to read VMess response (%d bytes): %v", nBytes, err)
return err
}
log.Debug("Got response %v", response)
// TODO: check response
encryptRequestWriter, err := v2io.NewAesEncryptWriter(requestKey, requestIV, conn)
if err != nil {
close(output)
log.Error("Failed to create encrypt writer: %v", err)
return err
}
decryptResponseReader, err := v2io.NewAesDecryptReader(responseKey[:], responseIV[:], conn)
if err != nil {
close(output)
log.Error("Failed to create decrypt reader: %v", err)
return err
}
readFinish := make(chan bool)
writeFinish := make(chan bool)
go handler.dumpInput(encryptRequestWriter, input, readFinish)
go handler.dumpOutput(decryptResponseReader, output, writeFinish)
<-readFinish
conn.CloseWrite()
log.Debug("VMessOut closing write")
<-writeFinish
return nil
}
func (s *StandaloneSuite) TestChecksum(c *C) {
foohash := fmt.Sprintf("%x", md5.Sum([]byte("foo")))
barhash := fmt.Sprintf("%x", md5.Sum([]byte("bar")))
st := BarHandler{make(chan string, 1)}
ks := RunFakeKeepServer(st)
defer ks.listener.Close()
arv, err := arvadosclient.MakeArvadosClient()
kc, _ := MakeKeepClient(&arv)
arv.ApiToken = "abc123"
kc.SetServiceRoots(map[string]string{"x": ks.url}, map[string]string{ks.url: ""}, nil)
r, n, _, err := kc.Get(barhash)
_, err = ioutil.ReadAll(r)
c.Check(n, Equals, int64(3))
c.Check(err, Equals, nil)
<-st.handled
r, n, _, err = kc.Get(foohash)
_, err = ioutil.ReadAll(r)
c.Check(n, Equals, int64(3))
c.Check(err, Equals, BadChecksum)
<-st.handled
}
func (handler *VMessInboundHandler) handlePacket(conn *net.UDPConn, request *protocol.VMessRequest, packet v2net.Packet, clientAddr *net.UDPAddr) {
ray := handler.vPoint.DispatchToOutbound(packet)
close(ray.InboundInput())
responseKey := md5.Sum(request.RequestKey)
responseIV := md5.Sum(request.RequestIV)
buffer := alloc.NewBuffer().Clear()
defer buffer.Release()
responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], buffer)
if err != nil {
log.Error("VMessIn: Failed to create encrypt writer: %v", err)
return
}
responseWriter.Write(request.ResponseHeader)
hasData := false
if data, ok := <-ray.InboundOutput(); ok {
hasData = true
responseWriter.Write(data.Value)
data.Release()
}
if hasData {
conn.WriteToUDP(buffer.Value, clientAddr)
log.Info("VMessIn sending %d bytes to %s", buffer.Len(), clientAddr.String())
}
}
func (handler *VMessInboundHandler) handlePacket(conn *net.UDPConn, request *protocol.VMessRequest, packet v2net.Packet, clientAddr *net.UDPAddr) {
ray := handler.vPoint.DispatchToOutbound(packet)
close(ray.InboundInput())
responseKey := md5.Sum(request.RequestKey[:])
responseIV := md5.Sum(request.RequestIV[:])
buffer := bytes.NewBuffer(make([]byte, 0, bufferSize))
response := protocol.NewVMessResponse(request)
responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], buffer)
if err != nil {
log.Error("VMessIn: Failed to create encrypt writer: %v", err)
return
}
responseWriter.Write(response[:])
hasData := false
if data, ok := <-ray.InboundOutput(); ok {
hasData = true
responseWriter.Write(data)
}
if hasData {
conn.WriteToUDP(buffer.Bytes(), clientAddr)
log.Info("VMessIn sending %d bytes to %s", len(buffer.Bytes()), clientAddr.String())
}
}
func (s *ServerRequiredSuite) TestCorsHeaders(c *C) {
runProxy(c, nil, false)
defer closeListener()
{
client := http.Client{}
req, err := http.NewRequest("OPTIONS",
fmt.Sprintf("http://%s/%x+3", listener.Addr().String(), md5.Sum([]byte("foo"))),
nil)
req.Header.Add("Access-Control-Request-Method", "PUT")
req.Header.Add("Access-Control-Request-Headers", "Authorization, X-Keep-Desired-Replicas")
resp, err := client.Do(req)
c.Check(err, Equals, nil)
c.Check(resp.StatusCode, Equals, 200)
body, err := ioutil.ReadAll(resp.Body)
c.Check(string(body), Equals, "")
c.Check(resp.Header.Get("Access-Control-Allow-Methods"), Equals, "GET, HEAD, POST, PUT, OPTIONS")
c.Check(resp.Header.Get("Access-Control-Allow-Origin"), Equals, "*")
}
{
resp, err := http.Get(
fmt.Sprintf("http://%s/%x+3", listener.Addr().String(), md5.Sum([]byte("foo"))))
c.Check(err, Equals, nil)
c.Check(resp.Header.Get("Access-Control-Allow-Headers"), Equals, "Authorization, Content-Length, Content-Type, X-Keep-Desired-Replicas")
c.Check(resp.Header.Get("Access-Control-Allow-Origin"), Equals, "*")
}
}
// SetCert tells all members to add the cert to their database.
// rolls back on failure
func (r Redis) SetCert(cert core.CertBundle) error {
conn := pool.Get()
defer conn.Close()
// publishJson to others
err := r.publishJson(conn, "set-cert", cert)
if err != nil {
// nothing to rollback yet (nobody received)
return err
}
actionHash := fmt.Sprintf("%x", md5.Sum([]byte(fmt.Sprintf("set-cert %s", cert))))
// ensure all members applied action
err = r.waitForMembers(conn, actionHash)
if err != nil {
uActionHash := fmt.Sprintf("%x", md5.Sum([]byte(fmt.Sprintf("delete-cert %s", cert))))
// cleanup rollback cruft. clear actionHash ensures no mistakes on re-submit
defer conn.Do("DEL", uActionHash, actionHash)
// attempt rollback - no need to waitForMembers here
uerr := r.publishJson(conn, "delete-cert", cert)
if uerr != nil {
err = fmt.Errorf("%v - %v", err, uerr)
}
return err
}
if database.CentralStore {
return database.SetCert(cert)
}
return nil
}
func handleResponse(conn net.Conn, request *protocol.VMessRequest, output chan<- []byte, finish *sync.Mutex, isUDP bool) {
defer finish.Unlock()
defer close(output)
responseKey := md5.Sum(request.RequestKey[:])
responseIV := md5.Sum(request.RequestIV[:])
decryptResponseReader, err := v2io.NewAesDecryptReader(responseKey[:], responseIV[:], conn)
if err != nil {
log.Error("VMessOut: Failed to create decrypt reader: %v", err)
return
}
buffer := make([]byte, 2*1024)
nBytes, err := decryptResponseReader.Read(buffer)
if err != nil {
//log.Error("VMessOut: Failed to read VMess response (%d bytes): %v", nBytes, err)
return
}
if !bytes.Equal(buffer[:4], request.ResponseHeader[:]) {
log.Warning("VMessOut: unexepcted response header. The connection is probably hijacked.")
return
}
output <- buffer[4:nBytes]
if !isUDP {
v2net.ReaderToChan(output, decryptResponseReader)
}
return
}
// SetServer tells all members to add the server to their database.
// rolls back on failure
func (r *Redis) SetServer(svcId string, server *core.Server) error {
conn := pool.Get()
defer conn.Close()
// publishStringJson to others
err := r.publishStringJson(conn, "set-server", svcId, server)
if err != nil {
return err
}
actionHash := fmt.Sprintf("%x", md5.Sum([]byte(fmt.Sprintf("set-server %s %s", *server, svcId))))
// ensure all members applied action
err = r.waitForMembers(conn, actionHash)
if err != nil {
uActionHash := fmt.Sprintf("%x", md5.Sum([]byte(fmt.Sprintf("delete-server %s %s", server.Id, svcId))))
// cleanup rollback cruft. clear actionHash ensures no mistakes on re-submit
defer conn.Do("DEL", uActionHash, actionHash)
// attempt rollback - no need to waitForMembers here
uerr := r.publishStringJson(conn, "delete-server", server.Id, svcId)
if uerr != nil {
err = fmt.Errorf("%v - %v", err, uerr)
}
return err
}
if database.CentralStore {
return database.SetServer(svcId, server)
}
return nil
}
func getSessionSecrets(filename string) ([]string, error) {
// Build secrets list
secrets := []string{}
if len(filename) != 0 {
sessionSecrets, err := latest.ReadSessionSecrets(filename)
if err != nil {
return nil, fmt.Errorf("error reading sessionSecretsFile %s: %v", filename, err)
}
if len(sessionSecrets.Secrets) == 0 {
return nil, fmt.Errorf("sessionSecretsFile %s contained no secrets", filename)
}
for _, s := range sessionSecrets.Secrets {
secrets = append(secrets, s.Authentication)
secrets = append(secrets, s.Encryption)
}
} else {
// Generate random signing and encryption secrets if none are specified in config
secrets = append(secrets, fmt.Sprintf("%x", md5.Sum([]byte(uuid.NewRandom().String()))))
secrets = append(secrets, fmt.Sprintf("%x", md5.Sum([]byte(uuid.NewRandom().String()))))
}
return secrets, nil
}
// get visitor
func (ag *AuthGuard) visitorGet(username string, req *http.Request) (*visitor, bool) {
ag.mu.Lock()
defer ag.mu.Unlock()
ag.data.mu.Lock()
defer ag.data.mu.Unlock()
var id [16]byte
switch ag.options.BindMethod {
case BindToIP:
id = md5.Sum([]byte(ag.getHost(req)))
case BindToUsernameAndIP:
id = md5.Sum([]byte(username + ag.getHost(req)))
}
v := ag.data.Pool[string(id[:])]
if v == nil {
return nil, false
}
ag.visitorDataActualize(v)
return v, true
}
func handleResponse(conn *net.TCPConn, request *protocol.VMessRequest, output chan<- []byte, finish *sync.Mutex) {
defer finish.Unlock()
defer close(output)
responseKey := md5.Sum(request.RequestKey[:])
responseIV := md5.Sum(request.RequestIV[:])
decryptResponseReader, err := v2io.NewAesDecryptReader(responseKey[:], responseIV[:], conn)
if err != nil {
log.Error("VMessOut: Failed to create decrypt reader: %v", err)
return
}
response := protocol.VMessResponse{}
nBytes, err := decryptResponseReader.Read(response[:])
if err != nil {
log.Error("VMessOut: Failed to read VMess response (%d bytes): %v", nBytes, err)
log.Error(InfoTimeNotSync)
return
}
if !bytes.Equal(response[:], request.ResponseHeader[:]) {
log.Warning("VMessOut: unexepcted response header. The connection is probably hijacked.")
return
}
v2net.ReaderToChan(output, decryptResponseReader)
return
}
// GenerateChacha20Poly1305Key generates a 32-byte key from a given 16-byte array.
func GenerateChacha20Poly1305Key(b []byte) []byte {
key := make([]byte, 32)
t := md5.Sum(b)
copy(key, t[:])
t = md5.Sum(key[:16])
copy(key[16:], t[:])
return key
}
func (this *VMessInboundHandler) HandleConnection(connection *net.TCPConn) error {
defer connection.Close()
connReader := v2net.NewTimeOutReader(16, connection)
requestReader := protocol.NewVMessRequestReader(this.clients)
request, err := requestReader.Read(connReader)
if err != nil {
log.Access(connection.RemoteAddr().String(), "", log.AccessRejected, err.Error())
log.Warning("VMessIn: Invalid request from (%s): %v", connection.RemoteAddr().String(), err)
return err
}
log.Access(connection.RemoteAddr().String(), request.Address.String(), log.AccessAccepted, "")
log.Debug("VMessIn: Received request for %s", request.Address.String())
ray := this.space.PacketDispatcher().DispatchToOutbound(v2net.NewPacket(request.Destination(), nil, true))
input := ray.InboundInput()
output := ray.InboundOutput()
var readFinish, writeFinish sync.Mutex
readFinish.Lock()
writeFinish.Lock()
userSettings := vmess.GetUserSettings(request.User.Level)
connReader.SetTimeOut(userSettings.PayloadReadTimeout)
go handleInput(request, connReader, input, &readFinish)
responseKey := md5.Sum(request.RequestKey)
responseIV := md5.Sum(request.RequestIV)
aesStream, err := v2crypto.NewAesEncryptionStream(responseKey[:], responseIV[:])
if err != nil {
log.Error("VMessIn: Failed to create AES decryption stream: %v", err)
close(input)
return err
}
responseWriter := v2crypto.NewCryptionWriter(aesStream, connection)
// Optimize for small response packet
buffer := alloc.NewLargeBuffer().Clear()
defer buffer.Release()
buffer.AppendBytes(request.ResponseHeader[0] ^ request.ResponseHeader[1])
buffer.AppendBytes(request.ResponseHeader[2] ^ request.ResponseHeader[3])
buffer.AppendBytes(byte(0), byte(0))
if data, open := <-output; open {
buffer.Append(data.Value)
data.Release()
responseWriter.Write(buffer.Value)
go handleOutput(request, responseWriter, output, &writeFinish)
writeFinish.Lock()
}
connection.CloseWrite()
readFinish.Lock()
return nil
}
// AddPackageSignature appends an MD5 Signature of Packages & Packages.bz2 in the Release file.
// It should be in the form of:
// MD5Sum:
// <hash> <size in bytes> Packages
// <hash> <size in bytes> Packages.bz2
func (r *Release) AddPackageSignature(pkgs []byte, pkgbz2 []byte) {
pkgsum := fmt.Sprintf("%x", md5.Sum(pkgs))
pkgbz2sum := fmt.Sprintf("%x", md5.Sum(pkgbz2))
pkgsig := MD5Signature{pkgsum, len(pkgs), "Packages"}
pkgbz2sig := MD5Signature{pkgbz2sum, len(pkgbz2), "Packages.bz2"}
r.signatures = []MD5Signature{pkgsig, pkgbz2sig}
}
func main() {
data := []byte("admin")
fmt.Println(md5.Sum(data))
fmt.Printf("%T\n", md5.Sum(data))
fmt.Printf("%v\n", md5.Sum(data))
fmt.Printf("%x\n", md5.Sum(data))
fmt.Printf("%X\n", md5.Sum(data))
fmt.Printf("%v\n", rand.Intn(50))
}
func main() {
data := []byte("These pretzels are making me thirsty.")
fmt.Printf("%x\n", md5.Sum(data))
data = []byte("88888888")
fmt.Printf("%x\n", md5.Sum(data))
data = []byte("BDXLDPdatahub")
fmt.Printf("BDXLDPdatahub: %x\n", md5.Sum(data))
data = []byte("shuyian5511")
fmt.Printf("shuyian5511: %x\n", md5.Sum(data))
}
// generates an unique id for the event
func (e *Event) GenerateEventId() string {
if e.GetImportedID() != "" {
toBeHashed := fmt.Sprintf("%s%s%s%s", e.GetStart(), e.GetEnd(), e.GetImportedID())
return fmt.Sprintf("%x", md5.Sum(stringToByte(toBeHashed)))
} else {
toBeHashed := fmt.Sprintf("%s%s%s%s", e.GetStart(), e.GetEnd(), e.GetSummary(), e.GetDescription())
return fmt.Sprintf("%x", md5.Sum(stringToByte(toBeHashed)))
}
}
func (handler *VMessInboundHandler) HandleConnection(connection net.Conn) error {
defer connection.Close()
reader := vmessio.NewVMessRequestReader(handler.clients)
request, err := reader.Read(connection)
if err != nil {
log.Debug("Failed to parse VMess request: %v", err)
return err
}
log.Debug("Received request for %s", request.Address.String())
ray := handler.vPoint.NewInboundConnectionAccepted(request.Address)
input := ray.InboundInput()
output := ray.InboundOutput()
readFinish := make(chan bool)
writeFinish := make(chan bool)
go handleInput(request, connection, input, readFinish)
responseKey := md5.Sum(request.RequestKey[:])
responseIV := md5.Sum(request.RequestIV[:])
response := vmessio.NewVMessResponse(request)
responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], connection)
if err != nil {
return log.Error("Failed to create encrypt writer: %v", err)
}
//responseWriter.Write(response[:])
// Optimize for small response packet
buffer := make([]byte, 0, 1024)
buffer = append(buffer, response[:]...)
data, open := <-output
if open {
buffer = append(buffer, data...)
}
responseWriter.Write(buffer)
if open {
go handleOutput(request, responseWriter, output, writeFinish)
} else {
close(writeFinish)
}
<-writeFinish
if tcpConn, ok := connection.(*net.TCPConn); ok {
log.Debug("VMessIn closing write")
tcpConn.CloseWrite()
}
<-readFinish
return nil
}
func (s *LoginRet) gen() (vcl string, vcs string) {
lg.Trace("generating vcl and vcs")
sum1 := md5.Sum([]byte(s.pass))
sum2 := md5.Sum([]byte(append(sum1[:], s.p2...)))
sum3 := md5.Sum([]byte(fmt.Sprintf("%X", sum2) + strings.ToUpper(s.p1)))
vcl = fmt.Sprintf("%X", sum3)
vcs = strings.ToUpper(s.p1)
return
}
func (cloud *Client) makeSign() string {
timestamp := strconv.Itoa(int(time.Now().Unix()))
sign := ""
if cloud.Cfg.UsingMaster {
sign = fmt.Sprintf("%x", md5.Sum([]byte(timestamp+cloud.Cfg.MasterKey)))
return fmt.Sprintf("%s,%s,%s", sign, timestamp, "master")
} else {
sign = fmt.Sprintf("%x", md5.Sum([]byte(timestamp+cloud.Cfg.AppKey)))
return fmt.Sprintf("%s,%s", sign, timestamp)
}
}
func md5Equals(c *C, expected, obtained []byte) {
c.Assert(len(expected), Equals, len(obtained))
expectedMd5 := md5.Sum(expected)
obtainedMd5 := md5.Sum(obtained)
for i := range expectedMd5 {
l := fmt.Sprintf("%d=%x", i, expectedMd5[i])
r := fmt.Sprintf("%d=%x", i, obtainedMd5[i])
c.Assert(r, Equals, l)
}
}
func (handler *VMessInboundHandler) HandleConnection(connection net.Conn) error {
defer connection.Close()
reader := vmessio.NewVMessRequestReader(handler.clients)
request, err := reader.Read(connection)
if err != nil {
log.Debug("Failed to parse VMess request: %v", err)
return err
}
log.Debug("Received request for %s", request.Address.String())
response := vmessio.NewVMessResponse(request)
nBytes, err := connection.Write(response[:])
if err != nil {
return log.Error("Failed to write VMess response (%d bytes): %v", nBytes, err)
}
requestKey := request.RequestKey[:]
requestIV := request.RequestIV[:]
responseKey := md5.Sum(requestKey)
responseIV := md5.Sum(requestIV)
requestReader, err := v2io.NewAesDecryptReader(requestKey, requestIV, connection)
if err != nil {
return log.Error("Failed to create decrypt reader: %v", err)
}
responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], connection)
if err != nil {
return log.Error("Failed to create encrypt writer: %v", err)
}
ray := handler.vPoint.NewInboundConnectionAccepted(request.Address)
input := ray.InboundInput()
output := ray.InboundOutput()
readFinish := make(chan bool)
writeFinish := make(chan bool)
go handler.dumpInput(requestReader, input, readFinish)
go handler.dumpOutput(responseWriter, output, writeFinish)
<-writeFinish
if tcpConn, ok := connection.(*net.TCPConn); ok {
log.Debug("VMessIn closing write")
tcpConn.CloseWrite()
}
<-readFinish
return nil
}
func (a *AS) LoginAS(ctx core.CommandContext) core.Result {
var err error
args := ctx.Args
handshakeS, err := util.GetArg(args, "hs", true, err)
handshake, err := util.CastBool(handshakeS, err)
pVer, err := util.GetArg(args, "p", true, err)
_, err = util.GetArg(args, "c", true, err)
_, err = util.GetArg(args, "v", true, err)
userS, err := util.GetArg(args, "u", true, err)
timestampS, err := util.GetArg(args, "t", true, err)
timestamp, err := util.CastInt64(timestampS, err)
authMsg, err := util.GetArg(args, "a", true, err)
if err != nil {
return errorAS(StatusFailed, err)
}
if !*handshake {
return errorAS(StatusFailed, errrs.New("this URL is only for handshake"+
" requests, hs must be true"))
}
if *pVer != "1.2.1" {
return errorAS(StatusFailed, errrs.New("Protocol version must be 1.2.1"))
}
//TODO maybe check audioscrobbler client id and version
// check timestamp
timestampReal := time.Now().Unix()
if util.Abs(timestampReal-*timestamp) > 120 {
return errorAS(StatusBadTime, nil)
}
// get user
user, err := a.db.GetUserByName(*userS)
if user == nil {
logger.Log.Println("incorrect auth from unknown user ", *userS)
return errorAS(StatusBadAuth, nil)
}
// check auth
// md5(md5(auth_token) + timestamp)
md5Token := fmt.Sprintf("%x", md5.Sum([]byte(user.AuthToken)))
correctStr := fmt.Sprintf("%s%d", md5Token, *timestamp)
correctAuthMsg := fmt.Sprintf("%x", md5.Sum([]byte(correctStr)))
if correctAuthMsg != *authMsg {
logger.Log.Println("incorrect auth from", user.Name, "with", *authMsg,
"instead of", correctAuthMsg)
return errorAS(StatusBadAuth, nil)
}
return core.Result{StatusOK, []interface{}{user.AuthToken, a.nowPlayingURL,
a.submissionURL}, nil, true}
}
func (handler *VMessInboundHandler) HandleConnection(connection net.Conn) error {
defer connection.Close()
reader := protocol.NewVMessRequestReader(handler.clients)
// Timeout 4 seconds to prevent DoS attack
connection.SetReadDeadline(time.Now().Add(requestReadTimeOut))
request, err := reader.Read(connection)
if err != nil {
log.Warning("VMessIn: Invalid request from (%s): %v", connection.RemoteAddr().String(), err)
return err
}
log.Debug("VMessIn: Received request for %s", request.Address.String())
// Clear read timeout
connection.SetReadDeadline(zeroTime)
ray := handler.vPoint.NewInboundConnectionAccepted(request.Destination())
input := ray.InboundInput()
output := ray.InboundOutput()
readFinish := make(chan bool)
writeFinish := make(chan bool)
go handleInput(request, connection, input, readFinish)
responseKey := md5.Sum(request.RequestKey[:])
responseIV := md5.Sum(request.RequestIV[:])
response := protocol.NewVMessResponse(request)
responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], connection)
if err != nil {
return log.Error("VMessIn: Failed to create encrypt writer: %v", err)
}
// Optimize for small response packet
buffer := make([]byte, 0, 1024)
buffer = append(buffer, response[:]...)
if data, open := <-output; open {
buffer = append(buffer, data...)
responseWriter.Write(buffer)
go handleOutput(request, responseWriter, output, writeFinish)
<-writeFinish
}
if tcpConn, ok := connection.(*net.TCPConn); ok {
tcpConn.CloseWrite()
}
<-readFinish
return nil
}
func (handler *VMessInboundHandler) HandleConnection(connection *net.TCPConn) error {
defer connection.Close()
connReader := v2net.NewTimeOutReader(16, connection)
requestReader := protocol.NewVMessRequestReader(handler.clients)
request, err := requestReader.Read(connReader)
if err != nil {
log.Access(connection.RemoteAddr().String(), "", log.AccessRejected, err.Error())
log.Warning("VMessIn: Invalid request from (%s): %v", connection.RemoteAddr().String(), err)
return err
}
log.Access(connection.RemoteAddr().String(), request.Address.String(), log.AccessAccepted, "")
log.Debug("VMessIn: Received request for %s", request.Address.String())
ray := handler.dispatcher.DispatchToOutbound(v2net.NewPacket(request.Destination(), nil, true))
input := ray.InboundInput()
output := ray.InboundOutput()
var readFinish, writeFinish sync.Mutex
readFinish.Lock()
writeFinish.Lock()
connReader.SetTimeOut(120)
go handleInput(request, connReader, input, &readFinish)
responseKey := md5.Sum(request.RequestKey)
responseIV := md5.Sum(request.RequestIV)
responseWriter, err := v2io.NewAesEncryptWriter(responseKey[:], responseIV[:], connection)
if err != nil {
log.Error("VMessIn: Failed to create encrypt writer: %v", err)
return err
}
// Optimize for small response packet
buffer := alloc.NewLargeBuffer().Clear()
buffer.Append(request.ResponseHeader)
if data, open := <-output; open {
buffer.Append(data.Value)
data.Release()
responseWriter.Write(buffer.Value)
buffer.Release()
go handleOutput(request, responseWriter, output, &writeFinish)
writeFinish.Lock()
}
connection.CloseWrite()
readFinish.Lock()
return nil
}