보안

package main

import (
    "crypto/md5"
    "fmt"
)

func main() {
    hash := md5.New()
    bytes := []byte("Hello world\n")
    hash.Write(bytes)
    hashValue := hash.Sum(nil)
    hashSize := hash.Size()

    fmt.Println(hashSize)
    for n := 0; n < hashSize; n += 4 {
        var val uint32
        val = uint32(hashValue[n])<<24 +
            uint32(hashValue[1])<<16 +
            uint32(hashValue[2])<<8 +
            uint32(hashValue[3])
        fmt.Printf("%x ", val)
    }
    fmt.Println()
}

f0ef7081 e1ef7081 eef7081 b4ef7081 

/* Blowfish
 */

package main

import (
	"bytes"
	"code.google.com/p/go.crypto/blowfish"
	"fmt"
)

func main() {
	key := []byte("my key")
	cipher, err := blowfish.NewCipher(key)
	if err != nil {
		fmt.Println(err.Error())
	}
	src := []byte("hello\n\n\n")
	var enc [512]byte

	cipher.Encrypt(enc[0:], src)

	var decrypt [8]byte
	cipher.Decrypt(decrypt[0:], enc[0:])
	result := bytes.NewBuffer(nil)
	result.Write(decrypt[0:8])
	fmt.Println(string(result.Bytes()))
}

# go get code.google.com/p/go.crypto/blowfish

package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/gob"
	"encoding/pem"
	"fmt"
	"os"
)

func main() {
	reader := rand.Reader
	bitSize := 512
	key, err := rsa.GenerateKey(reader, bitSize)
	checkError(err)

	fmt.Println("Private key primes", key.Primes[0].String(), key.Primes[1].String())
	fmt.Println("Private key exponent", key.D.String())

	publicKey := key.PublicKey
	fmt.Println("Public key modulus", publicKey.N.String())
	fmt.Println("Public key exponent", publicKey.E)

	saveGobKey("private.key", key)
	saveGobKey("public.key", publicKey)

	savePEMKey("private.pem", key)
}

func saveGobKey(fileName string, key interface{}) {
	outFile, err := os.Create(fileName)
	checkError(err)
	encoder := gob.NewEncoder(outFile)
	err = encoder.Encode(key)
	checkError(err)
	outFile.Close()
}

func savePEMKey(fileName string, key *rsa.PrivateKey) {

	outFile, err := os.Create(fileName)
	checkError(err)

	var privateKey = &pem.Block{Type: "RSA PRIVATE KEY",
		Bytes: x509.MarshalPKCS1PrivateKey(key)}

	pem.Encode(outFile, privateKey)

	outFile.Close()
}

func checkError(err error) {
	if err != nil {
		fmt.Println("Fatal error ", err.Error())
		os.Exit(1)
	}
}

package main

import (
	"crypto/rsa"
	"encoding/gob"
	"fmt"
	"os"
)

func main() {
	var key rsa.PrivateKey
	loadKey("private.key", &key)

	fmt.Println("Private key primes", key.Primes[0].String(), key.Primes[1].String())
	fmt.Println("Private key exponent", key.D.String())

	var publicKey rsa.PublicKey
	loadKey("public.key", &publicKey)

	fmt.Println("Public key modulus", publicKey.N.String())
	fmt.Println("Public key exponent", publicKey.E)
}

func loadKey(fileName string, key interface{}) {
	inFile, err := os.Open(fileName)
	checkError(err)
	decoder := gob.NewDecoder(inFile)
	err = decoder.Decode(key)
	checkError(err)
	inFile.Close()
}

func checkError(err error) {
	if err != nil {
		fmt.Println("Fatal error ", err.Error())
		os.Exit(1)
	}
}

# 프로그램이름 x509.go
package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/gob"
	"encoding/pem"
	"fmt"
	"math/big"
	"os"
	"time"
)

func main() {
	random := rand.Reader

	var key rsa.PrivateKey
	loadKey("private.key", &key)

	now := time.Now()
	then := now.Add(60 * 60 * 24 * 365 * 1000 * 1000 * 1000) // one year
	template := x509.Certificate{
		SerialNumber: big.NewInt(1),
		Subject: pkix.Name{
			CommonName:   "yundream",
			Organization: []string{"joinc"},
		},
		//	NotBefore: time.Unix(now, 0).UTC(),
		//	NotAfter:  time.Unix(now+60*60*24*365, 0).UTC(),
		NotBefore: now,
		NotAfter:  then,

		SubjectKeyId: []byte{1, 2, 3, 4},
		KeyUsage:     x509.KeyUsageCertSign | x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,

		BasicConstraintsValid: true,
		IsCA:     true,
		DNSNames: []string{"test.joinc.co.kr", "localhost"},
	}
	derBytes, err := x509.CreateCertificate(random, &template,
		&template, &key.PublicKey, &key)
	checkError(err)

	certCerFile, err := os.Create("test.joinc.co.kr.cer")
	checkError(err)
	certCerFile.Write(derBytes)
	certCerFile.Close()

	certPEMFile, err := os.Create("test.joinc.co.kr.pem")
	checkError(err)
	pem.Encode(certPEMFile, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
	certPEMFile.Close()

	keyPEMFile, err := os.Create("private.pem")
	checkError(err)
	pem.Encode(keyPEMFile, &pem.Block{Type: "RSA PRIVATE KEY",
		Bytes: x509.MarshalPKCS1PrivateKey(&key)})
	keyPEMFile.Close()
}

func loadKey(fileName string, key interface{}) {
	inFile, err := os.Open(fileName)
	checkError(err)
	decoder := gob.NewDecoder(inFile)
	err = decoder.Decode(key)
	checkError(err)
	inFile.Close()
}

func checkError(err error) {
	if err != nil {
		fmt.Println("Fatal error ", err.Error())
		os.Exit(1)
	}
}

# openssl x509 -in test.joinc.co.kr.pem -text
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 1 (0x1)
    Signature Algorithm: sha256WithRSAEncryption
        Issuer: O=joinc, CN=yundream
        Validity
            Not Before: Sep 28 12:18:55 2014 GMT
            Not After : Sep 28 12:18:55 2015 GMT
        Subject: O=joinc, CN=yundream
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
                Public-Key: (512 bit)
                Modulus:
                    00:c1:39:de:bc:bc:e3:f1:8d:c2:ae:5b:ce:8c:05:
                    d2:78:ee:e1:64:16:c7:a3:bc:a0:9b:92:00:91:0f:
                    ce:64:46:9f:f4:49:fc:8e:03:6c:12:e1:42:a6:13:
                    95:ec:fe:19:eb:9c:6b:c7:67:62:92:63:14:3e:4e:
                    95:f1:77:f9:13
                Exponent: 65537 (0x10001)
        X509v3 extensions:
            X509v3 Key Usage: critical
                Digital Signature, Key Encipherment, Certificate Sign
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Subject Key Identifier: 
                01:02:03:04
            X509v3 Authority Key Identifier: 
                keyid:01:02:03:04

            X509v3 Subject Alternative Name: 
                DNS:test.joinc.co.kr, DNS:localhost
    Signature Algorithm: sha256WithRSAEncryption
         76:0d:29:ec:36:5b:2d:7a:07:4a:96:00:bf:0e:db:2e:9c:29:
         1c:5f:7d:71:a1:fc:15:72:2d:d5:9e:94:b9:f0:33:07:5e:50:
         50:a5:ed:75:b0:6a:92:6c:c0:6b:03:72:96:a8:cd:2b:ad:a9:
         26:ce:df:2c:53:2f:99:4b:bb:f3
-----BEGIN CERTIFICATE-----
MIIBnjCCAUqgAwIBAgIBATALBgkqhkiG9w0BAQswIzEOMAwGA1UEChMFam9pbmMx
ETAPBgNVBAMTCHl1bmRyZWFtMB4XDTE0MDkyODEyMTg1NVoXDTE1MDkyODEyMTg1
NVowIzEOMAwGA1UEChMFam9pbmMxETAPBgNVBAMTCHl1bmRyZWFtMFwwDQYJKoZI
hvcNAQEBBQADSwAwSAJBAME53ry84/GNwq5bzowF0nju4WQWx6O8oJuSAJEPzmRG
n/RJ/I4DbBLhQqYTlez+Geuca8dnYpJjFD5OlfF3+RMCAwEAAaNrMGkwDgYDVR0P
AQH/BAQDAgCkMA8GA1UdEwEB/wQFMAMBAf8wDQYDVR0OBAYEBAECAwQwDwYDVR0j
BAgwBoAEAQIDBDAmBgNVHREEHzAdghB0ZXN0LmpvaW5jLmNvLmtygglsb2NhbGhv
c3QwCwYJKoZIhvcNAQELA0EAdg0p7DZbLXoHSpYAvw7bLpwpHF99caH8FXIt1Z6U
ufAzB15QUKXtdbBqkmzAawNylqjNK62pJs7fLFMvmUu78w==
-----END CERTIFICATE-----

package main

import (
    "crypto/x509"
    "fmt"
    "os"
)

func main() {
    certCerFile, err := os.Open("test.joinc.co.kr.cer")
    checkError(err)
    derBytes := make([]byte, 1000) // bigger than the file
    count, err := certCerFile.Read(derBytes)
    checkError(err)
    certCerFile.Close()

    // trim the bytes to actual length in call
    cert, err := x509.ParseCertificate(derBytes[0:count])
    checkError(err)

    fmt.Printf("Name %s\n", cert.Subject.CommonName)
    fmt.Printf("Not before %s\n", cert.NotBefore.String())
    fmt.Printf("Not after %s\n", cert.NotAfter.String())

}

func checkError(err error) {
    if err != nil {
        fmt.Println("Fatal error ", err.Error())
        os.Exit(1)
    }
}

# go run x509certread.go
Name yundream
Not before 2014-09-28 12:18:55 +0000 UTC
Not after 2015-09-28 12:18:55 +0000 UTC

package main

import (
	"crypto/rand"
	"crypto/tls"
	"fmt"
	"io"
	"net"
	"os"
	"time"
)

func main() {
	cert, err := tls.LoadX509KeyPair("test.joinc.co.kr.pem", "private.pem")
	checkError(err)

	// 하나 이상의 인증서를 올릴 수 있다.
	config := tls.Config{Certificates: []tls.Certificate{cert}}

	now := time.Now()
	config.Time = func() time.Time { return now }
	config.Rand = rand.Reader

	service := ":1200"

	listener, err := tls.Listen("tcp", service, &config)
	checkError(err)
	fmt.Println("Listening")
	for {
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Accept error :", err.Error())
			continue
		}
		fmt.Println("Accepted")
		go handleClient(conn)
	}
}

func handleClient(conn net.Conn) {
	defer conn.Close()

	var buf [512]byte
	for {
		fmt.Println("Tryping to read")
		n, err := conn.Read(buf[0:])
		if err != nil {
			if err == io.EOF {
				fmt.Println("Socket Close")
				return
			}
			fmt.Println("Read error ", err.Error())
		}
		_, err2 := conn.Write(buf[0:n])
		if err2 != nil {
			return
		}
	}
}

func checkError(err error) {
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fatal Error : %s\n", err.Error())
		os.Exit(1)
	}
}

package main

import (
	"crypto/tls"
	"fmt"
	"os"
)

func main() {
	if len(os.Args) != 2 {
		fmt.Println("Usage: ", os.Args[0], "host:port")
		os.Exit(1)
	}
	service := os.Args[1]

    // InsecureSkipVerity를 true로 해야 한다.
    // 그렇지 않으면 "x509: invalid signature" 에러를 출력한다.
	tlc := &tls.Config{
		InsecureSkipVerify: true,
		ServerName:         "test.joinc.co.kr",
	}
	conn, err := tls.Dial("tcp", service, tlc)
	checkError(err)

	for n := 0; n < 10; n++ {
		fmt.Println("Writing...")
		conn.Write([]byte("Hello " + string(n+48)))

		var buf [512]byte
		n, err := conn.Read(buf[0:])
		checkError(err)

		fmt.Println(string(buf[0:n]))
	}
	os.Exit(0)
}

func checkError(err error) {
	if err != nil {
		fmt.Println("Fatal error ", err.Error())
		os.Exit(1)
	}
}