n'a pas réussi à se connecter à la sécurité sur grpc?

Question

J'ai déjà changé plusieurs fois le numéro de port sur le serveur et le client, mais le serveur reçoit toujours le numéro de port incorrect.

quand j'exécute le client le serveur enregistre ceci: 2017/05/07 15:06:07 grpc: Server.Serve failed to complete security handshake from "127.0.0.1:32763": remote error: tls: bad certificate et du côté client, je me suis ceci: 2017/05/07 15:06:07 Failed to dial localhost:8070: connection error: desc = "transport: x509: certificate is not valid for any names, but wanted to match localhost:8070"; please retry. rpc error: code = Internal desc = connection error: desc = "transport: x509: certificate is not valid for any names, but wanted to match localhost:8070"

J'ai ce code pour le server.go

func serve() { 
    addr := "localhost:8070" 
    crt, key := certificate.CreatePemKey() 
    certificate, err := tls.X509KeyPair(crt, key) 
    if err != nil { 
     fmt.Println(err) 
    } 

    certPool := x509.NewCertPool() 
    ca, err := ioutil.ReadFile("F:/GIAG3.crt") 
    if err != nil { 
     fmt.Println(err) 
    } 

    if ok := certPool.AppendCertsFromPEM(ca); !ok { 
     fmt.Println("unable to append certificate") 
    } 

    lis, err := net.Listen("tcp", addr) 
    if err != nil { 
     fmt.Println("could not list on %s: %s", addr, err) 
    } 

    // Create the TLS credentials 
    creds := credentials.NewTLS(&tls.Config{ 
     ClientAuth: tls.RequireAndVerifyClientCert, 
     Certificates: []tls.Certificate{certificate}, 
     ClientCAs: certPool, 
    }) 

    srv := grpc.NewServer(grpc.Creds(creds)) 
    pb.RegisterPingerServer(srv, &server{}) 

    if err := srv.Serve(lis); err != nil { 
     fmt.Println("grpc serve error: %s", err) 
    } 
} 

et ceci est pour le client.go

func testDial2() { 
    addr := "localhost:8070" 
    crt, key := certificate.CreatePemKey() 
    certificate, err := tls.X509KeyPair(crt, key) 
    if err != nil { 
     fmt.Println(err) 
    } 

    certPool := x509.NewCertPool() 
    ca, err := ioutil.ReadFile("F:/GIAG3.crt") 
    if err != nil { 
     fmt.Println(err) 
    } 

    if ok := certPool.AppendCertsFromPEM(ca); !ok { 
     fmt.Println("unable to append certificate") 
    } 

    creds := credentials.NewTLS(&tls.Config{ 
     ServerName: addr, 
     Certificates: []tls.Certificate{certificate}, 
     RootCAs:  certPool, 
    }) 

    conn, err := grpc.Dial(addr, grpc.WithTransportCredentials(creds)) 
    if err != nil { 
     fmt.Println(err) 
    } 

    defer conn.Close() 
    c := pb.NewPingerClient(conn) 
    r, err := c.Ping(context.Background(), &pb.Payload{Message: "Ping"}) 
    if err != nil { 
     fmt.Println(err) 
    } 
    log.Printf("%s", r.Message) 
} 

ceci est pour le CreatePemKey, il est basé sur cet exemple https://golang.org/src/crypto/tls/generate_cert.go

func publicKey(priv interface{}) interface{} { 
    switch k := priv.(type) { 
    case *rsa.PrivateKey: 
     return &k.PublicKey 
    case *ecdsa.PrivateKey: 
     return &k.PublicKey 
    default: 
     return nil 
    } 
} 

func pemBlockForKey(priv interface{}) *pem.Block { 
    switch k := priv.(type) { 
    case *rsa.PrivateKey: 
     return &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(k)} 
    case *ecdsa.PrivateKey: 
     b, err := x509.MarshalECPrivateKey(k) 
     if err != nil { 
      fmt.Fprintf(os.Stderr, "Unable to marshal ECDSA private key: %v", err) 
      os.Exit(2) 
     } 
     return &pem.Block{Type: "EC PRIVATE KEY", Bytes: b} 
    default: 
     return nil 
    } 
} 

func CreatePemKey() (certpem, keypem []byte) { 
    priv, _ := rsa.GenerateKey(rand.Reader, 2048) 
    notBefore := time.Now() 
    notAfter := notBefore.AddDate(1, 0, 0) 
    serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128) 
    serialNumber, _ := rand.Int(rand.Reader, serialNumberLimit) 

    template := x509.Certificate{ 
     SerialNumber: serialNumber, 
     Subject: pkix.Name{ 
      Organization: []string{"Acme Co"}, 
     }, 
     NotBefore:    notBefore, 
     NotAfter:    notAfter, 
     KeyUsage:    x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature, 
     ExtKeyUsage:   []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, 
     BasicConstraintsValid: true, 
    } 
    // template.IPAddresses = append(template.IPAddresses, net.ParseIP("localhost")) 
    template.IsCA = true 
    derbytes, _ := x509.CreateCertificate(rand.Reader, &template, &template, publicKey(priv), priv) 
    certpem = pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: derbytes}) 
    keypem = pem.EncodeToMemory(pemBlockForKey(priv)) 
    return certpem, keypem 
} 

BTW le GIAG3.crt est venu d'ici https://pki.goog/

S'il vous plaît aidez-moi, merci

Answer 1

Si votre certificat de serveur n'a pas la définition de domaine et il n'est pas signé par GIAG3 (comme votre exemple), vous devez ajouter InsecureSkipVerify (cela vous permet d'ignorer la validation du nom du serveur et du certificat du serveur) dans la configuration du client, cela corrigera le problème avec le nom invalide.

creds := credentials.NewTLS(&tls.Config{ 
    ServerName: addr, 
    Certificates: []tls.Certificate{certificate}, 
    RootCAs:  certPool, 
    InsecureSkipVerify: true, 
}) 

Mais vous aurez un autre problème, parce que le client utilise un certificat auto-signé, et le serveur requis un certificat signé par GIAG3 pour l'authentification (tls.RequireAndVerifyClientCert), de sorte que vous avez des options avec cela,

• vous utilisez un certificat signé par GIAG3 pour le client.
• réduire le type d'authentification à tls.RequireAnyClientCert, cela vous permet d'utiliser n'importe quel certificat au moment de l'auth (il peut être signé ou non par GIAG3), le client a juste besoin d'utiliser un certificat lorsqu'il est connecté. Supprimez l'authentification du client avec le certificat.