[C++] DHKey Exchange in 5672

// Package for the diffie-hellman key exchange and its alternatives. The
// Conquer Online game client uses DH to establish a shared key for CAST-5
// over an insecure communications channel. This does not assist in reducing
// active attacks, and thus adds very little security to the server. Only
// helps reduce passive attacks such as eavesdropping. This package has been
// modified for interoperability with the Conquer Online game client.
package dh

import (
    "bytes"
    "crypto/rand"
    "crypto/md5"
    "encoding/hex"
    "math/big"
)

const (
    Generator = "05"
    Modulus   = "E7A69EBDF105F2A6BBDEAD7E798F76A209AD73FB466431E2E7352ED2" +
                "62F8C558F10BEFEA977DE9E21DCEE9B04D245F300ECCBBA03E726305" +
                "56D011023F9E857F"
)

// Exchange defines DH protocol for the server. For documentation purposes,
// the server will be Alice in the exchange protocol. Some variables are 
// captitalized incorrectly to be exported.
type Server struct {
    P *big.Int // Public prime modulus, known to all parties.
    G *big.Int // Public prime generator, known to both parties.
    A *big.Int // Alice's public key, known to both parties
    a *big.Int // Alice's private key.
    B *big.Int // Bob's public key (the client's public key).
}

// NewServer accepts a prime modulus and generator for initializing DH.
func NewServer(p, g string) *Server {
    
    server := new(Server)
    server.P = new(big.Int)
    server.G = new(big.Int)
    server.P.SetString(p, 16)
    server.G.SetString(g, 16)
    return server
}

// Request starts the exchange and generates the server's public key to be 
// sent over the unsecure communications channel. Returns the public key as
// a hexadecimal string to be sent to the game client.
func (server *Server) Request() (string, error) {
    
    var err error
    server.a, err = rand.Prime(rand.Reader, 256)
    if err != nil { return "", err }
    server.A = server.G.Exp(server.G, server.a, server.P)
    return server.A.Text(16), nil
}

// Response to be processed from the game client. The response contains the
// client's public key. From this key, the shared key can be computed between
// the parties. Returns the shared key.
func (server *Server) Response(clientkey string) []byte {
    
    server.B = new(big.Int)
    server.B.SetString(clientkey, 16)
    sharedkey := server.B.Exp(server.B, server.a, server.P)
    
    // The shared key is trimmed for some reason in TQ's version.
    sharedkeybuf := sharedkey.Bytes()
    sharedkeylen := len(sharedkeybuf)
    trimmedkeylen := bytes.IndexByte(sharedkeybuf, 0)
    if trimmedkeylen == -1 { trimmedkeylen = sharedkeylen }
    trimmedkey := sharedkeybuf[:trimmedkeylen]
    
    // TQ Digital hash modification to the shared key.
    hash := md5.New()
    hash.Write(trimmedkey)
    left := hex.EncodeToString(hash.Sum(nil))
    right := left + left
    
    hash = md5.New()
    hash.Write([]byte(right))
    right = hex.EncodeToString(hash.Sum(nil))
    return []byte(left + right)
}