time包中的Add和Sub的用法，Add用于计算某个时间之前和之后的时间点，Sub用于计算两个时间差

package main

import (

"fmt"

"strings"

"time"

)

func main() {

// Add 时间相加

now := time.Now()

// ParseDuration parses a duration string.

// A duration string is a possibly signed sequence of decimal numbers,

// each with optional fraction and a unit suffix,

// such as "300ms", "-1.5h" or "2h45m".

//  Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".

// 10分钟前

m, _ := time.ParseDuration("-1m")

m1 := now.Add(m)

fmt.Println(m1)

// 8个小时前

h, _ := time.ParseDuration("-1h")

h1 := now.Add(8 * h)

fmt.Println(h1)

// 一天前

d, _ := time.ParseDuration("-24h")

d1 := now.Add(d)

fmt.Println(d1)

printSplit(50)

// 10分钟后

mm, _ := time.ParseDuration("1m")

mm1 := now.Add(mm)

fmt.Println(mm1)

// 8小时后

hh, _ := time.ParseDuration("1h")

hh1 := now.Add(hh)

fmt.Println(hh1)

// 一天后

dd, _ := time.ParseDuration("24h")

dd1 := now.Add(dd)

fmt.Println(dd1)

printSplit(50)

// Sub 计算两个时间差

subM := now.Sub(m1)

fmt.Println(subM.Minutes(), "分钟")

sumH := now.Sub(h1)

fmt.Println(sumH.Hours(), "小时")

sumD := now.Sub(d1)

fmt.Printf("%v 天\n", sumD.Hours()/24)

}

func printSplit(count int) {

fmt.Println(strings.Repeat("#", count))

}

 http://studygolang.com/articles/650

 http://blog.csdn.net/fyxichen/article/details/50991805

golang时间处理
相关包 "time"

• 时间戳 
  当前时间戳

  fmt.Println(time.Now().Unix()) # 1389058332

   

• str格式化时间
  当前格式化时间

  fmt.Println(time.Now().Format("2006-01-02 15:04:05")) # 这是个奇葩,必须是这个时间点, 据说是go诞生之日, 记忆方法:6-1-2-3-4-5 # 2014-01-07 09:42:20

   

• 时间戳转str格式化时间

  str_time := time.Unix(1389058332, 0).Format("2006-01-02 15:04:05") fmt.Println(str_time) # 2014-01-07 09:32:12

• str格式化时间转时间戳
  这个比较麻烦

  the_time := time.Date(2014, 1, 7, 5, 50, 4, 0, time.Local) unix_time := the_time.Unix() fmt.Println(unix_time) # 389045004

  还有一种方法,使用time.Parse

  the_time, err := time.Parse("2006-01-02 15:04:05", "2014-01-08 09:04:41") if err == nil {         unix_time := the_time.Unix() 	fmt.Println(unix_time)		 } # 1389171881

 http://studygolang.com/articles/9959

主代码: package rsa  import (     "crypto/rand"     "crypto/rsa"     "crypto/x509"     "crypto/x509/pkix"     "encoding/pem"     "io/ioutil"     "math/big"     rd "math/rand"     "os"     "time" )  func init() {     rd.Seed(time.Now().UnixNano()) }  type CertInformation struct {     Country            []string     Organization       []string     OrganizationalUnit []string     EmailAddress       []string     Province           []string     Locality           []string     CommonName         string     CrtName, KeyName   string     IsCA               bool     Names              []pkix.AttributeTypeAndValue }  func CreateCRT(RootCa *x509.Certificate, RootKey *rsa.PrivateKey, info CertInformation) error {     Crt := newCertificate(info)     Key, err := rsa.GenerateKey(rand.Reader, 2048)     if err != nil {         return err     }      var buf []byte     if RootCa == nil || RootKey == nil {         //创建自签名证书         buf, err = x509.CreateCertificate(rand.Reader, Crt, Crt, &Key.PublicKey, Key)     } else {         //使用根证书签名         buf, err = x509.CreateCertificate(rand.Reader, Crt, RootCa, &Key.PublicKey, RootKey)     }     if err != nil {         return err     }      err = write(info.CrtName, "CERTIFICATE", buf)     if err != nil {         return err     }      buf = x509.MarshalPKCS1PrivateKey(Key)     return write(info.KeyName, "PRIVATE KEY", buf) } //编码写入文件 func write(filename, Type string, p []byte) error {     File, err := os.Create(filename)     defer File.Close()     if err != nil {         return err     }     var b *pem.Block = &pem.Block{Bytes: p, Type: Type}     return pem.Encode(File, b) }  func Parse(crtPath, keyPath string) (rootcertificate *x509.Certificate, rootPrivateKey *rsa.PrivateKey, err error) {     rootcertificate, err = ParseCrt(crtPath)     if err != nil {         return     }     rootPrivateKey, err = ParseKey(keyPath)     return }  func ParseCrt(path string) (*x509.Certificate, error) {     buf, err := ioutil.ReadFile(path)     if err != nil {         return nil, err     }     p := &pem.Block{}     p, buf = pem.Decode(buf)     return x509.ParseCertificate(p.Bytes) }  func ParseKey(path string) (*rsa.PrivateKey, error) {     buf, err := ioutil.ReadFile(path)     if err != nil {         return nil, err     }     p, buf := pem.Decode(buf)     return x509.ParsePKCS1PrivateKey(p.Bytes) }  func newCertificate(info CertInformation) *x509.Certificate {     return &x509.Certificate{         SerialNumber: big.NewInt(rd.Int63()),         Subject: pkix.Name{             Country:            info.Country,             Organization:       info.Organization,             OrganizationalUnit: info.OrganizationalUnit,             Province:           info.Province,             CommonName:         info.CommonName,             Locality:           info.Locality,             ExtraNames:         info.Names,         },         NotBefore:             time.Now(),//证书的开始时间         NotAfter:              time.Now().AddDate(20, 0, 0),//证书的结束时间         BasicConstraintsValid: true, //基本的有效性约束         IsCA:           info.IsCA,   //是否是根证书         ExtKeyUsage:    []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},    //证书用途         KeyUsage:       x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,         EmailAddresses: info.EmailAddress,     } } 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

测试代码: package rsa  import (     "crypto/x509/pkix"     "encoding/asn1"     "os"     "testing" )  func Test_crt(t *testing.T) {     baseinfo := CertInformation{Country: []string{"CN"}, Organization: []string{"WS"}, IsCA: true,         OrganizationalUnit: []string{"work-stacks"}, EmailAddress: []string{"czxichen@163.com"},         Locality: []string{"SuZhou"}, Province: []string{"JiangSu"}, CommonName: "Work-Stacks",         CrtName: "test_root.crt", KeyName: "test_root.key"}      err := CreateCRT(nil, nil, baseinfo)     if err != nil {         t.Log("Create crt error,Error info:", err)         return     }     crtinfo := baseinfo     crtinfo.IsCA = false     crtinfo.CrtName = "test_server.crt"     crtinfo.KeyName = "test_server.key"     crtinfo.Names = []pkix.AttributeTypeAndValue{{asn1.ObjectIdentifier{2, 1, 3}, "MAC_ADDR"}} //添加扩展字段用来做自定义使用      crt, pri, err := Parse(baseinfo.CrtName, baseinfo.KeyName)     if err != nil {         t.Log("Parse crt error,Error info:", err)         return     }     err = CreateCRT(crt, pri, crtinfo)     if err != nil {         t.Log("Create crt error,Error info:", err)     }     os.Remove(baseinfo.CrtName)     os.Remove(baseinfo.KeyName)     os.Remove(crtinfo.CrtName)     os.Remove(crtinfo.KeyName) }

http://blog.csdn.net/fyxichen/article/details/53010255

 安全总是很重要的，各个语言对于通用的加密算法都会有实现。前段时间，用Go实现了RSA和DES的加密解密，在这分享一下。（对于RSA和DES加密算法本身，请查阅相关资料）

在PHP中，很多功能经常是一个函数解决；而Go中的却不是。本文会通过PHP加密，Go解密；Go加密，PHP解密来学习Go的RSA和DES相关的API。

该文讨论Go RSA加密解密。所有操作在linux下完成。

一、概要

这是一个非对称加密算法，一般通过公钥加密，私钥解密。

在加解密过程中，使用openssl生产密钥。执行如下操作：

1）创建私钥：
openssl genrsa -out private.pem 1024 //密钥长度，1024觉得不够安全的话可以用2048，但是代价也相应增大
2）创建公钥：
openssl rsa -in private.pem -pubout -out public.pem

这样便生产了密钥。

一般地，各个语言也会提供API，用于生成密钥。在Go中，可以查看encoding/pem包和crypto/x509包。具体怎么产生，可查看《GO加密解密RSA番外篇：生成RSA密钥》。

加密解密这块，涉及到很多标准，个人建议需要的时候临时学习一下。

http://blog.studygolang.com/2013/01/go%E5%8A%A0%E5%AF%86%E8%A7%A3%E5%AF%86%E4%B9%8Brsa/

-------------------

http://www.golangtc.com/t/54c0c8ff421aa95374000091